设计模式——策略模式

定义:策略模式定义了一系列算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化.

�使用场景:我们要对一串数字进行排序,�并且能够选择排序算法.
那么就会产生许多不同的策略来解决排序问题
我们可以把策略的公共部分提取出来,成为抽象策略类,然后再去实现各个具体策略类.然后使用工具类,可以聚合抽象策略类
代码如下

//抽象策略类
public interface Algorithm {

    void sort(int[] numbers);
}

//具体的策略类
public class QuickSort implements Algorithm {
    @Override
    public void sort(int[] numbers) {
        if(numbers != null){
            quickSort(numbers, 0, numbers.length-1);
        }

    }

    private static void quickSort(int[] array,int beg,int end){
        if(beg >= end || array == null)
            return;
        int p = partition(array, beg, end);
        quickSort(array, beg, p-1);
        quickSort(array, p+1, end);
    }

    private static int partition(int[] array, int beg, int end) {
        int first = array[beg];
        int i = beg, j = end;
        while (i < j) {
            while (array[i] <= first && i < end) {
                i++;
            }
            while (array[j] > first && j >= beg) {
                j--;
            }
            if (i < j) {
                array[i] = array[i] ^ array[j];
                array[j] = array[i] ^ array[j];
                array[i] = array[i] ^ array[j];
            }
        }
        if (j != beg) {
            array[j] = array[beg] ^ array[j];
            array[beg] = array[beg] ^ array[j];
            array[j] = array[beg] ^ array[j];
        }
        return j;
    }


}


public class SortUtil {

    private static class SortUtilHolder{
        private static final SortUtil INSTANCE = new SortUtil();
    }

    private Algorithm algorithm;

    private SortUtil(){}

    public static SortUtil getInstance(){
        return SortUtilHolder.INSTANCE;
    }

    public void setAlgorithm(Algorithm algorithm) {
        this.algorithm = algorithm;
    }

    public void sort(int[] numbers){
        if(algorithm != null){
            algorithm.sort(numbers);
        }
    }
}

策略模式的UML如下图

其中SortUtil相当于Context,Algorithm相当于Strategy,而QuickSort则是Algorithm的实现类.
这其实也是OOP六大原则中的典型的依赖倒置
通过替换Algorithm来达到替换策略.
说到底其实策略模式就是面向接口编程的体现,通过接口和继承替换了方法