关于后端:策略模式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，一个乐观的码农，撰写乏味的文章。\
如果这篇文章帮忙到你，请珍藏⭐点赞👍加关注👀，跟踪不迷路 (🌻◡‿◡)

策略模式

代码实现