strategy-pattern

问题 I am learning design patterns and trying to follow Go4 book. On page:179, in the decorator pattern chapter, there is a line which says "..by extending the number of strategies from just one to an open-ended list, we achieve the same effect as nesting decorators recursively." I didn't quite get this statement. Strategies focus on having independent algorithms, which can be set dynamically and don't know much about the client they are set in. Whereas decorators are not quite independent of the

问题 I am learning design patterns and trying to follow Go4 book. On page:179, in the decorator pattern chapter, there is a line which says "..by extending the number of strategies from just one to an open-ended list, we achieve the same effect as nesting decorators recursively." I didn't quite get this statement. Strategies focus on having independent algorithms, which can be set dynamically and don't know much about the client they are set in. Whereas decorators are not quite independent of the

问题 I am learning design patterns and trying to follow Go4 book. On page:179, in the decorator pattern chapter, there is a line which says "..by extending the number of strategies from just one to an open-ended list, we achieve the same effect as nesting decorators recursively." I didn't quite get this statement. Strategies focus on having independent algorithms, which can be set dynamically and don't know much about the client they are set in. Whereas decorators are not quite independent of the

问题 I know this question's been asked before (e.g., What is the difference between the bridge pattern and the strategy pattern?). However, could someone please explain, using clear-cut examples, what the difference is and in what sorts of cases one must be selected over the other? Less conceptual theory, more practical "real-life" scenarios would be appreciated. 回答1: The Bridge Pattern makes a distinction between an abstraction and an implementation in such a way that the two can vary

问题 It seems the need for a type like the following would be so ubiquitous that something like it should be already built into Java: public interface Executer<T> { void execute(T object); } It can then be used in other classes like this trivial example that calls a bunch of executers on an object. class Handler<T> implements Executer<T> { List<Executer<T>> executerList; Handler(List<Executer<T>> executer) { this.executerList = executer; } void execute(T t) { for (Executer<T> executer : this

问题 I need to process a list of records returned from a service. However the processing algorithm for a record changes completely based on a certain field on the record. To implement this , I have defined an IProcessor interface which has just one method : public interface IProcessor { ICollection<OutputEntity> Process(ICollection<InputEntity>> entities); } And I have two concrete implementations of IProcessor for the different types of processing. The issue is that I need to use all

问题 In the OO world, I have a class (let's call it "Suggestor") that implement something approaching a "Strategy Pattern" to provide differing implementations of an algorithm at runtime. As an exercise in learning Haskell, I want to rewrite this. The actual use-case is quite complex, so I'll boil down a simpler example. Let's say I have a class Suggester that's takes a list of rules, and applies each rule as a filter to a list of database results. Each rule has three phases "Build Query", "Post

问题 I am redesigning a library and I am not happy with the current design pattern. This question concerns the use of the strategy pattern in conjunction with a State monad I have a Filter . All it does, in its basic implementation, is to take a some datafeed of type 'd and update itself, generating a new updated copy of itself. [<AbstractClass>] type Filter<'d, 'F> (state: 'F) = member val StateVariable = state with get abstract member Update: 'd -> Filter<'d, 'F> I have then a ISignalGenerator ,

问题 Here's a simplified example of what is called (I hope - please, correct me if I'm wrong) Strategy pattern: there's a class FileWriter which writes key-value pairs to a file and uses object of IFormatter interface for formatting text being written. There are different formatters implementations and formatter object is passed when FileWriter is created. Here's one (bad) implementation of such pattern: #include <iostream> #include <fstream> #include <stdlib.h> #include <sstream> using namespace

问题 Here's a simplified example of what is called (I hope - please, correct me if I'm wrong) Strategy pattern: there's a class FileWriter which writes key-value pairs to a file and uses object of IFormatter interface for formatting text being written. There are different formatters implementations and formatter object is passed when FileWriter is created. Here's one (bad) implementation of such pattern: #include <iostream> #include <fstream> #include <stdlib.h> #include <sstream> using namespace