一、简介：

   意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

      主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

      何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

      如何解决：将这些算法封装成一个一个的类，任意地替换。

      关键代码：实现同一个接口。

      应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

       优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

       缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

       使用场景：

       1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

       2、一个系统需要动态地在几种算法中选择一种。

       3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

       注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

       我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。

StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。

1、抽象策略（Strategy）角色：抽象策略角色由抽象类或接口来承担，它给出具体策略角色需要实现的接口；

2、具体策略（ConcreteStrategy）角色：实现封装了具体的算法或行为；

3、上下文（Context）角色：持有抽象策略类的引用。（引用，执行策略）

二、代码（Java）：

步骤 1：创建一个接口

OperationAdd.java

public interface Strategy {
   public int doOperation(int num1, int num2);
}

步骤 2：创建实现接口的实体类

OperationAdd.java

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

OperationSubstract.java

public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

OperationMultiply.java

public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

步骤 3：创建 Context 类

public class Context {
   private Strategy strategy;
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

步骤 4：使用 Context 来查看当它改变策略 Strategy 时的行为变化

StrategyPatternDemo.java

public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
      context = new Context(new OperationSubstract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

步骤 5：执行程序，输出结果

10 + 5 = 15

10 - 5 = 5

10 * 5 = 50

三、实际应用：

  学习设计模式时，我们知道设计模式中有这样一个原则：开闭原则，要求代码对扩展开放，对修改关闭。

      这个意思就是说，如果我想增加一个新的功能，我可以很容易的在不改变已测试过的代码的前提下增加新的代码。有好几个设计模式是基于开闭原则的，如策略模式，如果我需要一个新的策略，只需要实现接口，增加配置，不需要改变核心逻辑。

      在实际项目中，我是这样用的：有一个特殊的题型，在不同的科目中，判分规则不同，老师制定了ABC三种判分规则。我们使用策略模式，定义判分策略接口，把之前老师的制定的三种判分策略单独封装成类，实现策略接口。在数据库字典中，建立“判分策略”字典。

      当老师在页面上选择判分策略时，比如选中“A策略”，系统查询数据库，获取“A策略”对应的字典值（每个策略对应的字典值与策略实现类的名字相同），在后端，通过反射机制实例化该字段对应的策略类。

      这样，当老师再添加判分规则，我们只需要在数据库中添加字典值，添加新的判分策略的接口，封装新的判分规则类实现该即接口即可。不用修改核心逻辑代码（如果我们使用if...else的方式，需要在核心代码中，添加if判断）。

      主要介绍我在项目中是如何使用策略模式的，策略模式的经典应用：商场商品打折，在这里就不再赘述了，各位读者自行百度吧。

参考：

菜鸟教程：策略模式 | 菜鸟教程

最近5年133个Java面试问题列表 - 知乎