介绍

  1. 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
  2. 这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来；第二、针对接口编程而不是具体类（定义了策略接口）；第三、多用组合聚合， 少用继承（客户通过组合方式使用策略）。

原理image-20201017171657167.png

说明：从上图可以看到，客户context 有成员变量strategy或者其他的策略接口,至于需要使用到哪个策略，我们可以在构造器中指定.

案例

编写鸭子项目，具体要求如下:

  1. 有各种鸭子(比如 野鸭、北京鸭、水鸭等， 鸭子有各种行为，比如 叫、飞行等)
  2. 显示鸭子的信息

image-20201017172058950.png

  1. //飞行策略（实际就是一个借口）定义了飞行方法
  2. public interface FlyBehavior {
  3.     public void fly();
  4. }
  6. //三个飞行策略实现类
  7. public class GoodFly implements FlyBehavior{
  8.     @Override
  9.     public void fly() {
  10.         System.out.println("飞行的非常好");
  11.     }
  12. }
  14. public class NoFly implements FlyBehavior {
  15.     @Override
  16.     public void fly() {
  17.         System.out.println("不会飞行");
  18.     }
  19. }
  21. public class BadFly implements FlyBehavior{
  22.     @Override
  23.     public void fly() {
  24.         System.out.println("不擅长飞行");
  25.     }
  26. }
  1. //抽象鸭子类
  2. public abstract class Duck {
  3.     String name;
  4.     FlyBehavior flyBehavior;        //聚合飞行策略对象，实现飞行方法时使用
  6.     public Duck(String name) {
  7.         this.name = name;
  8.     }
  10.     public void setFlyBehavior(FlyBehavior flyBehavior) {    //动态设置策略使用
  11.         this.flyBehavior = flyBehavior;
  12.     }
  14.     public void yell(){
  15.         System.out.println("嘎嘎叫");
  16.     }
  17.     public abstract void fly();
  18. }
  1. //具体鸭子实现类
  2. public class YeDuck extends Duck{
  3.     public YeDuck(String name) {        //构造鸭子对象时给策略对象赋值
  4.         super(name);
  5.         flyBehavior = new NoFly();
  6.     }
  8.     @Override
  9.     public void fly() {
  10.         System.out.print(name);
  11.         flyBehavior.fly();
  12.     }
  13. }
  15. //具体鸭子实现类
  16. public class WaterDuck extends Duck{
  17.     public WaterDuck(String name) {        //构造鸭子对象时给策略对象赋值
  18.         super(name);
  19.         flyBehavior = new BadFly();
  20.     }
  22.     @Override
  23.     public void fly() {
  24.         System.out.print(name);
  25.         flyBehavior.fly();
  26.     }
  27. }
  29. //具体鸭子实现类
  30. public class BeijingDuck extends Duck {
  32.     public BeijingDuck(String name) {        //构造鸭子对象时给策略对象赋值
  33.         super(name);
  34.         flyBehavior = new GoodFly();
  35.     }
  37.     @Override
  38.     public void fly() {
  39.         System.out.print(name);
  40.         flyBehavior.fly();
  41.     }
  42. }
  1. //策略模式除了用默认的策略外，还可以动态设置策略
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         new YeDuck("野鸭").fly();
  5.         new WaterDuck("水鸭").fly();
  6.         new BeijingDuck("北京鸭").fly();
  7.         System.out.println("---------------------------");
  8.         //可动态设置鸭子的飞行描述
  9.         Duck duck = new YeDuck("野鸭2");
  10.         duck.fly();
  11.         duck.setFlyBehavior(new GoodFly());
  12.         duck.fly();
  13.     }
  14. }

image-20201017172757591.png

策略模式的注意事项和细节

  1. 策略模式的关键是：分析项目中变化部分与不变部分
  2. 策略模式的核心思想是：多用组合/聚合 少用继承；用行为类组合，而不是行为的继承。更有弹性
  3. 体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if..else if..else）
  4. 提供了可以替换继承关系的办法： 策略模式将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展
  5. 需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大