策略模式：23种设计模式的思想基础

先让我们看个题目：设计一个鸭子父类表示所有的鸭子，要求所有鸭子子类实现父类中的叫，跑两个功能。
你或许会这样设计：

public class Duck {
    public void run(){
        System.out.println("鸭子左摇右摆的跑");
    }
    public  void call(){
        System.out.println("鸭子嘎嘎的叫");
    }
}

让每个鸭子类都继承 Duck, 这样所有的鸭子可以直接使用父类中的方法，也可以通过重写方法，实现其它鸭子自己的需求，你心里想，这也太简单了 (‾◡◝)。

理想很丰满，现实很残酷，我们只说设计鸭子子类，实现父类两个功能，但没说是什么鸭子，如果是烤鸭呢，它不会跑，只会很香。而它的实现是这样的

public class BBQDuck {
    public void run(){
        System.out.println("烤鸭不会跑");
    }
    public  void call(){
        System.out.println("烤鸭冒油滋滋叫");
    }
}

这样的例子还有很多，比如小黄鸭玩具车只会向前跑，唐老鸭会说话等等等等，我们无法预测以后会有什么样的鸭子加入。但显而易见的是，通过继承父类重写是行不通的，因为不可能把每个鸭子的 run、call 方法都重写一遍。且有的实现和父类不同却在子类中通用，比如天津板鸭和北京烤鸭都会 “冒油滋滋叫” 等。那么问题如何解决呢，这个时候就需要策略模式的登场了。

策略模式

定义一系列算法， 将每种算法分别放入独立的类中， 使算法能够相互替换。

结合上面的例子，我们通过策略模式，将上面的 “烤鸭冒油滋滋叫” 抽取成一个独立的类，暂且叫做 “滋滋类”。当再出现一个上海烤鸭的时候，我们只需要让上海烤鸭使用滋滋类实现滋滋叫功能，不必再去类中重新实现重复内容，从而减少开发中的冗余。

当不需要滋滋类，我们可以替换成其他的功能类，并且该功能类需要改变时，我们只需要更改类中的代码，让所有使用该功能类的子类一同改变，使代码解耦，且更加灵活。

代码实现

• 定义所需要的功能接口

  public interface Runnable {
    public void run();
  }

  public interface Callable {
    public void call();
  }

  在我们上述提到的例子里，因为 run、call 方法里的内容是不断变化的，所以我们就把这种公共使用但是变化的方法抽取出来进行封装，而 Callable 和 Runnable 接口 (我们自己定义的) 代表我们要使用的功能，通过接口实现多态。

这种把公共变化部分抽取出来进行封装，从而提高代码的维护和扩展，正是所有设计模式中的核心思想所在。

• 定义一个鸭子类代表所有鸭子

  public class  Duck {
    private Callable callable;
    private Runnable runnable;
    
    public Duck(Callable callable, Runnable runnable) {
        this.callable = callable;
        this.runnable = runnable;
    }
    public void action(){
        callable.call();
        runnable.run();
    }
  }

  Duck 构造器传入实现该接口的具体功能类，action 方法调用我们传入对象的具体行为。

• 实现 Runnable 接口

  public class LeftRightRun implements Runnable {
    @Override
    public void run() {
        System.out.println("左摇右摆的跑");
    }
  }

  public class NoRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("不会跑");
    }
  }

  public class ForwardRun implements Runnable{
    @Override
    public void run() {
        System.out.println("向前跑");
    }
  }

• 实现 Callable 接口

  public class NoCallable implements Callable {
    @Override
    public void call() {
        System.out.println("不会叫");
    }
  }

  public class SpecialCall implements Callable {
    @Override
    public void call() {
        System.out.println("独特的叫");
    }
  }

• 编写测试类

  public class strategyDemo {
    public static void main(String[] args) {
        Duck BBQDuck = new Duck(new SpecialCall(), new NoRunnable());\\烤鸭
        Duck TangDuck = new Duck(new SpecialCall(), new LeftRightRun());\\唐老鸭
        Duck DuckCar = new Duck(new NoCallable(), new ForwardRun());\\玩具车鸭
  
        System.out.println("烤鸭具有的行为：");
        BBQDuck.action();
        System.out.println("唐老鸭具有的行为：");
        TangDuck.action();
        System.out.println("鸭子玩具车具有的行为：");
        DuckCar.action();
    }
  }

• 运行结果

这样，我们就设计了一个完美的鸭子。

我是 Haoo，一个乐观的码农，撰写有趣的文章。\
如果这篇文章帮助到你，请收藏⭐点赞加关注，跟踪不迷路(◡‿◡)