基本介绍：

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

    策略模式的UML类图：
    image.png
    从上图可以看到，客户Context有成员变量Strategy或者其他的策略接口，至于需要使用到哪个策略，可以在构造器中指定

    代码示例：

    1. public interface FlyBehavior {
    2.     void fly();
    3. }
    6. public class GoodFly implements FlyBehavior {
    7.     @Override
    8.     public void fly() {
    9.         System.out.println("擅长飞翔");
    10.     }
    11. }
    15. public class BadFly implements FlyBehavior {
    16.     @Override
    17.     public void fly() {
    18.         System.out.println("不擅长飞翔");
    19.     }
    20. }
    24. public class NoFly implements FlyBehavior {
    25.     @Override
    26.     public void fly() {
    27.         System.out.println("不能飞翔");
    28.     }
    29. }
    32. public abstract class Duck {
    34.     FlyBehavior flyBehavior;
    36.     public void swim(){
    37.         System.out.println("鸭子游戏");
    38.     }
    40.     public void fly(){
    41. //        System.out.println("鸭子飞翔");
    42.         if (flyBehavior != null){
    43.             flyBehavior.fly();
    44.         }
    45.     }
    46. }
    50. public class WildDuck extends Duck {
    52.     public WildDuck(){
    53.         flyBehavior = new GoodFly();
    54.     }
    55. }
    59. public class Client {
    60.     public static void main(String[] args) {
    61.         WildDuck wildDuck = new WildDuck();
    62.         wildDuck.fly();
    63.     }
    64. }

    JDk源码分析：JDK的Arrays的Comparator就使用了策略模式

    1. public static <T> void sort(T[] a, Comparator<? super T> c) {
    2.     if (c == null) {
    3.         sort(a);
    4.     } else {
    5.         if (LegacyMergeSort.userRequested)
    6.             legacyMergeSort(a, c);
    7.         else
    8.             TimSort.sort(a, 0, a.length, c, null, 0, 0);
    9.     }
    10. }

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

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