定义

  • 定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化不会影响到使用算法的用户。可以理解成：将不同的算法封装到不同的类中，让他们可以相互替换
  • 隶属于行为型设计模式

应用场景

  • 系统有很多类，而它们的区别仅仅在于行为不同
  • 一个系统需要动态的选择算法中的一种

优点

  • 对行为有很好的扩展，符合开闭原则
  • 避免了多重条件语句
  • 提高算法的保密和安全性

缺点

  • 客户端必须知道所有的策略类，并自行决定使用哪一种
  • 产生很多策略类

示例代码

  1. /**
  2.  * 策略模式，定义一个算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化不会影响到算法的使用。
  3.  * Strategy类 定义所有支持算法的公共接口
  4.  */
  5. public abstract class Strategy {
  6.     // 算法方法
  7.     public abstract void algorithmInterface();
  8. }
  1. /**
  2.  * 用一个ConcreteStrategy 来配置，维护一个对Strategy 引用
  3.  */
  4. public class Context {
  5.     private final Strategy strategy;
  6.     /**
  7.      * @param strategy 在初始化是传入具体的策略（strategy）
  8.      */
  9.     public Context(Strategy strategy) {
  10.         this.strategy = strategy;
  11.     }
  12.     /**
  13.      * 根据具体的策略对象，调用其算法的方法
  14.      */
  15.     public void contextInterface() {
  16.         strategy.algorithmInterface();
  17.     }
  18. }
  1. /**
  2.  * 具体的算法，继承Strategy
  3.  */
  4. public class ConcreteStrategyA extends Strategy {
  6.     @Override
  7.     public void algorithmInterface() {
  8.         System.out.println("算法A");
  9.     }
  10. }

客户端代码

  1. public class Main {
  2.     // 客户端代码
  3.     public static void main(String[] args) {
  4.         Context context = new Context(new ConcreteStrategyA());
  5.         // 执行指定策略的算法逻辑
  6.         context.contextInterface();
  7.     }
  8. }

策略模式解析

策略模式是一种定义一系列算法的方法，所有的算法完成都是相同的工作，但是实现不同，他可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。在客户端中判断用那一种算法计算使用了switch分支，当不同的行为堆砌在在一个类中时，就很难避免使用条件语句来选择合适的行为，将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。