策略模式(strategy pattern)

策略模式在java集合中的TreeSet和TreeMap中得到了很好的应用，我们可以实现Comparator接口实现Compareto()方法来定义自己的排序规则，然后通过TreeSet,TreeMap构造方法传入实现该接口的实例，map中的顺序就会是我们自定义的顺序。我们可以完全定义自己的规则，用之极为方便。那么，什么是策略模式呢？

策略模式定义：定义一组算法，将每个算法都封装起来，并且使它们之间可以转换。策略模式使这些算法在客户端调用时能够互不影响的变化。

策略模式组成：

　　　　　　　　1.抽象的策略角色：策略类，通常由一个抽象类或者接口实现。

　　　　　　　　2.具体的策略角色：包装了相关的算法和行为。

　　　　　　　　3.环境角色：持有一个策略类的引用，以便最终给客户端调用。

策略模式的设计原则:

　　　　　　　1. 封装变化

　　　　　　　2.使用接口编程

策略模式的实现：

　　　　　　　1.将每一组算法封装到具有共同接口的独立类中，这样不同的策略可以相互替换

　　　　　  2.算法可以在不影响客户端的情况下发生变化，把行为和环境分开。

　　　　　　 3.环境类负责维持和查询行为类，各种算法在具体策略中提供

看文字看蒙了，举一个具体的例子吧，举什么例子呢？想到我们数据结构中的各种排序，什么冒泡排序，快速排序，堆排序...，他们完成的功能都是一样的，只是排序算法不同而已。我们就可以看成是排序的不同策略。

首先定义我们的抽象策略：

/**
 * 抽象的策略类
 * @author
 *
 */
public interface Strategy {

    public void sort(int[] array);
}

定义具体的策略,这里实现了三种策略，分别是快速排序，堆排序，归并排序。

快速排序策略代码：

public class QuickSort implements Strategy{

    @Override
    public void sort(int[] array) {
        qpSort(array,0,array.length - 1);
    }

    private void qpSort(int array[], int low, int high) {
        int pos = qkPass(array, low, high); //产生中间第一个确定的数

        if (low < high) {
            qpSort(array, low, pos - 1);//左边
            qpSort(array, pos + 1, high);//右边
        }
    }

    private  int qkPass(int a[], int low, int high) {
        int x = a[low]; 

        while (low < high) {

            while (low < high && a[high] > x) {
                high--;
            }
            if (low < high) {
                a[low] = a[high];
                low++;
            }
            while (low < high && a[low] < x) {
                low++;
            }
            if (low < high) {
                a[high] = a[low];
                high--;
            }
        }
        a[low] = x;

        return low;
    }

}

堆排序策略代码：

public class HeapSort implements Strategy {

    @Override
    public void sort(int[] array) {
        heapSort(array,array.length);
    }

    private void heapSort(int a[], int length) {

        crtHeap(a, length); // 创建大根堆

        for (int i = length - 1; i > 0; i--) {

            int b = a[0];

            a[0] = a[i]; // 堆顶跟堆尾互换

            a[i] = b;

            sift(a, 0, i - 1); // 使得r[0...i-1]变成堆
        }
    }

    /**
     * 建立初堆
     *
     * @param a
     *            为带排序的数组
     * @param length
     *            为数组长度
     */
    private void crtHeap(int a[], int length) {

        int n = length - 1;

        // 建出堆，从第 n/2 个记录开始进行堆筛选
        for (int i = n / 2; i >= 0; i--) {

            sift(a, i, n);
        }
    }

    /**
     *
     * @param r
     *            数组
     * @param k
     *            表示以r[k]为根的完全二叉树，调整r[k]，使得r[k...m]满足大根堆的性质
     * @param m
     *            堆尾元素下标
     */
    private void sift(int r[], int k, int m) {

        int temp = r[k]; // 暂存根记录

        int i = k; // 记录初始根的下标

        int j = i * 2 + 1; // 根的左孩子,因为下标从0开始

        while (j <= m) {
            // 如果存在右子树，且右子树根的关键字大，则沿右分支筛选，否则沿左分支筛选。因为目的是找一个最大的元素
            if (j < m && r[j] < r[j + 1]) {
                j = j + 1;
            }

            if (temp >= r[j]) {
                break; // 结束筛选
            }
            else {
                r[i] = r[j]; // 上移
                i = j; // 从新定义根下标
                j = j * 2 + 1;// 继续筛选
            }
        }

        r[i] = temp; // 将r[k]移动到适当的位置
    }

}

归并排序策略代码:

public class MergeSort implements Strategy{

    @Override
    public void sort(int[] array) {
        int[] temp = new int[array.length];
        mSort(array,0,array.length - 1, temp);
    }

    /**
     *
     * @param r1 等待排序数组
     * @param low
     * @param high
     * @param r3  将r1排序后的结果放在r3中 r1[low...high],r3[low...high]
     */
    private void mSort(int r1[],int low,int high, int r3[]){

        if(low  < high)
        {
            int mid = (low + high) /2;

            //归并排序中 拆，合要一起进行
            mSort(r1,low,mid,r3);

            mSort(r1,mid+1,high,r3);

            merge(r1,low, mid, high, r3);
        }

    }

    private void merge(int r1[],int low, int mid, int high, int r2[]){

        int i = low;
        int j = mid + 1;
        int k = 0;

        while(i <=mid && j <= high){

            if(r1[i] <= r1[j]){
                r2[k] = r1[i];
                i++;
            }
            else{
                r2[k] = r1[j];
                j++;
            }

            k++;
        }

        while(i <= mid){
            r2[k] = r1[i];
            i++;
            k++;
        }

        while(j <= high){
            r2[k] = r1[j];
            j++;
            k++;
        }

        for(int m = 0; m < k;m++){
            r1[low + m] = r2[m];
        }
    }

}

定义环境类：

public class Environment {

    private Strategy strategy; //策略类的引用

    public Environment(Strategy strategy){
        this.strategy = strategy;
    }

    //用于设置不同的策略
    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }

    //实现排序的功能
    public void sort(int array[]){
        strategy.sort(array);
    }

}

最后定义客户端类：

public class Client {

    public static void main(String[] args) {

        int[] array1 = new int[]{48,62,35,77,55,14,35,98};
        int[] array2 = new int[]{48,62,35,77,55,14,35,98};
        int[] array3 = new int[]{48,62,35,77,55,14,35,98};

        //使用堆排序策略
        Environment env = new Environment(new HeapSort());

        env.sort(array1);
        System.out.println("使用堆排序array1：");
        print(array1);

        //使用快速排序策略
        env.setStrategy(new QuickSort());
        env.sort(array2);
        System.out.println("使用快速排序array2：");
        print(array2);

        //使用归并排序策略
        env.setStrategy(new MergeSort());
        env.sort(array3);
        System.out.println("使用归并排序array3：");
        print(array3);

    }

    static void print(int[] array){
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + "\t");
        }
        System.out.println();
        System.out.println("---------------------------------");
    }
}

运行结果如下所示：

我们使用不同的排序策略分别对三个数组排序的功能已经实现了，程序非常灵活，我们想用什么策略来实现排序可以自己决定（通过environment.serStrategy(XXX)方法）。

程序中Environment类根本不知道也不用管排序到底是怎么实现的，它只是持有一个具体策略类的引用，然后调用具体策略类的方法。

策略模式用着很方便，但是本身也有缺点：

　　　　1.客户端必须知道所有的策略类，并自行决定使用哪种策略类。

　  2.造成很多的策略类，每一个不同的策略都需要一个策略类来实现。

对于第一点很明显，我们客户端（client类）在使用策略时必须知道具体的策略类是什么，environment.serStrategy(XXX)方法也需要知道。

对于第二点，定义了3中策略，就有3个策略类，如果策略很多的话，类也会很多。

　

参考资料：圣思园教学视频