策略设计模式和工厂方法设计模式

Question

我开始学习设计模式。现在我明白了一些，但对我来说还有很多困惑。 策略DP和工厂方法DP有什么区别？对我来说，它们看起来都一样。

Answer 1

战略是关于行为的。工厂是关于创造/安装的。

假设您有一个算法来计算折扣百分比。您可以有该算法的 2 种实现；一种是针对常客，一种是针对特别好的客户。
您可以使用策略 DP 来实现此实现：创建一个接口和 2 个实现该接口的类。在一个类中，您实现常规折扣计算算法，在另一类中，您实现“好客户”算法。

然后，您可以使用工厂模式来实例化您想要的类。因此，工厂方法实例化常规客户折扣算法或其他实现。

简而言之：工厂方法实例化正确的类；策略实现包含必须执行的算法。

Answer 2

策略将不同的行为封装在同一接口后面。您可以使用 new 运算符实例化策略。例如（与 Frederik 建议的业务案例相同）：

DiscountCalculator calc = new GoogCustomerDiscountCalculator();
Integer discount = calc.calculate();

工厂方法封装了其他一些接口的实例化机制（可能是策略，但也可能是其他东西）。例如：

DiscountFactory factory = new DiscountFactory();
DiscountCalculator calc = factory.getDiscountCalculator();
Integer discount = calc.calculate();

Strategy模式经常与Factory Method一起使用，而Factory Method则经常用于其他构造型的实例化，而不仅仅是Strategies。

Answer 3

区别在于它们的意图：

工厂方法模式是一种创建模式，用于将对象实例化推迟到子类。另一方面，策略模式是一种行为模式，用于将算法与客户端代码解耦。

如果您需要通过定义返回特定类型实例的方法来抽象对象创建，但让子类实现它，则可以使用第一个。在 Java 中，示例如下：

public interface SomeAbstractObject {
   // methods...
}

public abstract class SomeAbstractClass {
  public abstract SomeAbstractObject newSomeObject();
  // Other methods...
}

public class SomeConcreteClassA extends SomeAbstractClass {
  public SomeAbstractObject newSomeObject() {
    // assuming SomeConcreteObjectA extends from SomeAbstractObject
    return new SomeConcreteObjectA();
  }
  // Other methods...
}

public class SomeConcreteClassB extends SomeAbstractClass {
  public SomeAbstractObject newSomeObject() {
    // assuming SomeConcreteObjectB extends form SomeAbstractObject
    return new SomeConcreteObjectB();
  }
  // Other methods...
}

请注意实际的对象实例化与 SomeAbstractClass 的实现有何不同。

另一方面，如果您需要将算法与调用代码解耦，则可以使用策略模式。这类似于MVC模式中View与Controller的通信方式。在假设 java MVC UI 工具包中，这可能如下所示：

// interface abstracting the algorithm of a user interaction with your ui components.
public interface ActionHandler {
   public void handle(Action a);
}

// concrete implementation of button clicked algorithm.
public class ButtonClickedHandler implements ActionHandler {
   public void handle(Action a) {
      // do some fancy stuff...
   }
}

public class Button extends Widget {

   // ActionHandler abstracts the algorithm of performing an action.
  private ActionHandler handler = new ButtonClickedHandler();

  // Delegates to the action handler to perform the action.
  public void execute(Action a) {
    handler.handle(a);
  }
}

现在，假设您有另一个组件，它不是单击响应滑动（即滑块），

public class Slider extends Widget {

  // SliderMovedHandler extends ActionHandler
  private ActionHandler handler = new SliderMovedHandler()

  // Delegates to action handler to perform the action.
  public void execute(Action a) {
    handler.handle(a);
  }
}

请注意 Button 和 Slider 类（视图）中的逻辑如何执行一个动作是完全相同的（都遵循 ActionHandler）。因此，我们可以将它们拉到父类（Widget）并让子类只定义操作处理程序实现，如下所示：

public class Widget {
  private ActionHandler handler;

  public Widget(ActionHandler handler) {
    this.handler = handler;
  }

  public void execute(Action a) {
    handler.handle(a);
  }
}

// concrete widget implementations change their behavior by configuring
// different action handling strategies.

public class Button extends Widget {
  public Button() {
    super(new ButtonClickedHandler());
  }
}

public class Slider extends Widget {
  public Slider() {
    super(new SliderMovedHandler());
  }
}

通过使用策略模式，我们可以通过使用 ActionHandler 的另一个具体实现配置它们来更改小部件的行为。通过这种方式，小部件（视图）与操作处理逻辑（控制器）松散耦合。

我们可以通过将策略和工厂方法模式混合在一起来使事情变得更有趣，如下所示：

public abstract class Widget {

  public void execute(Action a) {
    // action handling strategy is retrieved by a factory method
    ActionHandler handler = getActionHandler();
    handler.handle(a);
  }

  // factory method defers creation of action handling strategy to subclasses
  public abstract ActionHandler getActionHandler();
}

// factory method defines different action handling strategy for different subclass

public class Button extends Widget {
   public ActionHandler getActionHandler() {
     return new ButtonClickedHandler();
   }
}

public class Slider extends Widget {
   public ActionHandler getActionHandler() {
     return new SliderMovedHandler();
   }
}

请注意，这是策略模式的说明性示例，而不是 Swing（Java 的默认 UI 工具包）的实现方式。

两种模式有些相似，因为它们将某些逻辑片段推迟到其他地方。这是设计模式中的一个常见主题，可以实现关注点分离。然而，延迟逻辑的性质或意图是完全不同的。工厂方法将创建逻辑推迟到子类（在我的示例中，创建具体的 ActionHandler 实例），而策略模式则执行算法（在我的示例中，当用户与特定组件交互时要做什么）。

Answer 4

您可以在 http://javabyranjith 找到策略模式的另一个 Java 实现。 blogspot.in/2017/04/strategy-design-pattern.html

和

工厂方法设计模式位于 http://javabyranjith.blogspot.in/2014/06/factory-method-design-pattern.html