继续整理记录这段时间来的收获，详细代码可在我的Gitee仓库SpringBoot克隆下载学习使用！

6.3 策略模式

6.3.1 概述

• 定义了一系列算法，并将每个算法封装起来，使它们可以相互替代，且算法的变化不会影响使用算法的用户
• 属于对象行为模式，通过对算法进行封装，把使用算法的责任实现分割开，并委派给不同的对象对这些算法进行管理

6.3.2 结构

• 抽象策略类(Strategy)：抽象角色，由一个接口或抽象类实现，给出所有的具体策略类所需接口
• 具体策略类(Concrete Strategy)：实现策略定义接口，提供具体算法实现或行为
• 环境类(Context)：持有一个策略类的引用，最终给客户端调用

6.3.3 案例

• 抽象策略类

public interface Strategy {  
    /*展示促销活动*/  
    public void StrategyShow();  
}

• 具体策略类

public class StrategyA implements Strategy{  
    @Override  
//    春节促销  
    public void StrategyShow() {  
        System.out.println("买一送一");  
    }  
}
public class StrategyB implements Strategy{  
    @Override  
    /*中秋促销*/  
    public void StrategyShow() {  
        System.out.println("满200减50");  
    }  
}
public class StrategyC implements Strategy{  
    @Override  
    /*国庆促销*/  
    public void StrategyShow() {  
        System.out.println("满500减100");  
    }  
}

• 环境类

public class SalesMan implements Strategy{  
//    聚合具体策略  
    private Strategy strategy;  
    public Strategy getStrategy() {  
        return strategy;  
    }  
    public void setStrategy(Strategy strategy) {  
        this.strategy = strategy;  
    }  
    public SalesMan(Strategy strategy) {  
        this.strategy = strategy;  
    }  
    @Override  
    public void StrategyShow() {  
        strategy.StrategyShow();  
    }  
}

• 测试

 public static void main(String[] args) {  
//        春节促销  
        SalesMan salesMan = new SalesMan(new StrategyA());  
//        展示促销活动  
        salesMan.StrategyShow();  
        System.out.println("================");  
//        中秋促销  
        salesMan.setStrategy(new StrategyB());  
        //        展示促销活动  
        salesMan.StrategyShow();  
        System.out.println("================");  
        //        国庆促销  
        salesMan.setStrategy(new StrategyC());  
        //        展示促销活动  
        salesMan.StrategyShow();  
    }

• 结果
  
• 类图

6.3.4 优缺点

6.3.4.1 优点

• 策略类之间可以自由切换
• 易于扩展：增加新策略只需调价具体策略类即可
• 避免使用多重条件选择语句(if else)

6.3.4.2 缺点

• 客户端必须知道所有策略类，并自行决定使用哪一类
• 策略模式将造成产生很多策略类，可通过使用享元模式在一定程度上减少对象的数量

6.3.5 使用场景

• 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类
• 一个类定义了多种行为，并且这些行为在此类中操作中已多个条件语句形式出现，可将每个条件分支移入它们各自的策略类中代替条件语句
• 系统中各算法彼此完全独立，且要求对客户隐藏具体算法实现细节
• 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构
• 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为

6.3.6 JDK源码

Comparator中策略模式，在Arrays类中有一个sort()方法，如下：

public static <T> void sort(T[] a, Comparator<? super T> c) {  
    if (c == null) {  
        sort(a);  
    } else {  
        if (LegacyMergeSort.userRequested)  
            legacyMergeSort(a, c);  
        else            TimSort.sort(a, 0, a.length, c, null, 0, 0);  
    }  
}

Arrays相当于环境角色，sort()方法根据新策略让其排序，如下：

public static void main(String[] args) {  
    Integer [] data = {10,2,56,7,20,9};  
    Arrays.sort(data, new Comparator<Integer>() {  
        public int compare(Integer o1, Integer o2) {  
            return o1 - o2;  
        }  
    });  
    System.out.println(Arrays.toString(data));  
}

传的第二个参数是Comparator接口的子实现类对象，充当抽象策略对象角色，具体子实现类充当具体策略角色，最后使用的TimSort类的sort()方法，如下：

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,  
                     T[] work, int workBase, int workLen) {  
    assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;  
  
    int nRemaining  = hi - lo;  
    if (nRemaining < 2)  
        return;  // Arrays of size 0 and 1 are always sorted  
  
    // If array is small, do a "mini-TimSort" with no merges
        if (nRemaining < MIN_MERGE) {  
        int initRunLen = countRunAndMakeAscending(a, lo, hi, c);  
        binarySort(a, lo, hi, lo + initRunLen, c);  
        return;    }  
        ………………
}
private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,  
                                                Comparator<? super T> c) {  
    assert lo < hi;  
    int runHi = lo + 1;  
    if (runHi == hi)  
        return 1;  
    // Find end of run, and reverse range if descending  
    if (c.compare(a[runHi++], a[lo]) < 0) { // Descending  
        while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)  
            runHi++;  
        reverseRange(a, lo, runHi);  
    } else {                              // Ascending  
        while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)  
            runHi++;  
    }  
    return runHi - lo;  
}