策略模式

Define a family of algorithms, encapsulate each one, and make them interchangeable.

策略模式的通用类图

策略模式的通用代码

• 策略接口

  public interface IStrategy {
  
      //策略模式的运算法则
      public void doSomething();
  
  }
  

• 具体策略类1

  public class ConcreteStrategy1 implements IStrategy {
  
      @Override
      public void doSomething() {
          System.out.println("具体策略类1");
      }
  
  }
  

• 具体策略类2

  public class ConcreteStrategy2 implements IStrategy {
  
      @Override
      public void doSomething() {
          System.out.println("具体策略类2");
      }
  
  }       
  

• 封装策略角色类

  public class Context {
  
      private IStrategy strategy;
  
      public Context(IStrategy _strategy) {
          this.strategy = _strategy;
      }
  
      public void doSomething() {
          this.strategy.doSomething();
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Context context = null;
  
          System.out.println("策略1");
          context = new Context(new ConcreteStrategy1());
          context.doSomething();
  
          System.out.println("策略2");
          context = new Context(new ConcreteStrategy2());
          context.doSomething();
      }
  }
  

策略模式的优点

• 算法可以自由切换。这是策略模式自己本身定义的，只要实现策略接口（抽象策略类），它就成为策略家族的一个成员，通过封装策略角色类对其封装，保证对外提供“自由切换”的策略。
• 避免使用多重条件判断。使用策略模式后，可以由其他模块决定采用何种策略，策略家族对外提供的访问接口就是分装类，简化操作，避免了条件语句的判断。
• 扩展性良好。只要在现有的系统中扩展相应的策略即可。

策略模式的缺点

• 策略类数量的增多。每一个策略都是一个类，复用的可能想小，类的数量增多。
• 所有的策略类都需要对外暴露。上层模块必须知道有哪些策略，然后才决定使用哪个策略。

策略模式的使用场景

• 多个类只用在算法或行为上稍有不同的场景。
• 算法需要自由切换的场景。
• 需要屏蔽算法规则的场景。

注：策略模式中的策略家族的具体策略类数量超过4个时，要考虑采用混合模式。

策略模式的简单应用的类图及源码

• 策略接口

  public interface IStrategy {
  
      public void operate();
  
  }
  

• 具体策略类（走后门）

  public class BackDoor implements IStrategy {
  
      @Override
      public void operate() {
          System.out.println("找乔国老帮忙，让吴国太给孙权事假压力");
      }
  
  }
  

• 具体策略类（开绿灯）

  public class GivenGreenLight implements IStrategy {
  
      @Override
      public void operate() {
          System.out.println("求吴国太开绿灯，放行");
      }
  
  }
  

• 具体策略类3（挡住追兵）

  public class BlackEnemy implements IStrategy {
  
      @Override
      public void operate() {
          System.out.println("孙夫人断后，挡住追兵");
      }
  
  }
  

• 封装策略角色类

  public class Context {
  
      private IStrategy strategy;
  
      public Context(IStrategy _strategy) {
          this.strategy = _strategy;
      }
  
      public void operate() {
          this.strategy.operate();
      }
  
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Context context = null;
  
          System.out.println("拆第一个-----------------");
          context = new Context(new BackDoor());
          context.operate();
  
          System.out.println("拆第二个-----------------");
          context = new Context(new GivenGreenLight());
          context.operate();
  
          System.out.println("拆第三个-----------------");
          context = new Context(new BlackEnemy());
          context.operate();
      }
  }
  

策略模式的扩展##

策略模式的扩展1–最直接的加减法

• 加减法类

  public class Calculator {
  
      private final static String ADD_SYMBOL = "+";
      private final static String SUB_SYMBOL = "-";
  
      public int exec(int a, int b, String symbol) {
          int result = 0;
          if(symbol.equals(ADD_SYMBOL)) {
              result = this.add(a, b);
          }
          else if(symbol.equals(SUB_SYMBOL)){
              result = this.sub(a, b);
          }
          return result;
      }
  
      private int add(int a, int b) {
          return (a - b);
      }
  
      private int sub(int a, int b) {
          return (a + b);
      }
  
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Calculator calculator = new Calculator();
          System.out.println(calculator.exec(2, 1, "+"));
          System.out.println(calculator.exec(2, 1, "-"));
      }
  }
  

策略模式的扩展2–简化的加减法

• 加减法类

  public class Calculator {
  
      private final static String ADD_SYMBOL = "+";
      //private final static String SUB_SYMBOL = "-";
  
      public int exec(int a, int b, String symbol) {
          return symbol.equals(ADD_SYMBOL)? (a + b) : (a - b); 
      }
  
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Calculator calculator = new Calculator();
          System.out.println(calculator.exec(2, 1, "+"));
          System.out.println(calculator.exec(2, 1, "-"));
      }
  }
  

策略模式的扩展3–策略模式的加减法

• 策略接口

  public interface IStrategy {
  
      public int exec(int a, int b);
  
  }
  

• 具体策略类（加法）

  public class AddStrategy implements IStrategy {
  
      @Override
      public int exec(int a, int b) {
          return (a + b);
      }
  
  }
  

• 具体策略类（减法）

  public class SubStrategy implements IStrategy {
  
      @Override
      public int exec(int a, int b) {
          return (a - b);
      }
  
  }
  

• 封装策略角色类

  public class Context {
  
      private IStrategy strategy;
  
      public Context(IStrategy _strategy) {
          this.strategy = _strategy; 
      }
  
      public int exec(int a, int b) {
          return this.strategy.exec(a, b);
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Context context = null;
  
          System.out.println("+");
          context = new Context(new AddStrategy());
          System.out.println(context.exec(3, 1));
  
          System.out.println("-");
          context = new Context(new SubStrategy());
          System.out.println(context.exec(3, 1));
      }
  
  }
  

策略模式的扩展4–策略枚举的加减法###

• 策略枚举

  public enum Calculator {
  
      ADD("+") {
          public int exec(int a, int b) {
              return a + b;
          }
      },
      SUB("-") {
          public int exec(int a, int b) {
              return a - b;
          }
      };
  
      String value = "";
  
      //定义成员值类型
      private Calculator(String _value) {
          this.value = _value;
      }
  
      public abstract int exec(int a, int b);
  
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
          int a = 2;
          int b = 1;
          System.out.println(Calculator.ADD.exec(a, b));
      }
  }