设计模式--策略模式

　　定义：策略模式定义了一系列的算法（我个人对其理解就是解决某个问题的不同方法），并将每一个算法封装起来，而且使它们还可以相互替换。使得算法能独立于使用它的客户而独立变化。
　　
　　UML图：
　　
　　
　　该图体现了什么呢？？？对的，“面向接口编程”。

　　例如，下面有如下接口：

public interface OnSort {

    /**
     * 实现数组的顺序排序
     * */
    int[] sort(int[] old);
}

　　然后这里分别有两种不同的实现：

/**
 * 冒泡排序
 * */
public class BubbleSort implements OnSort{

    @Override
    public int[] sort(int[] old) {
        // TODO Auto-generated method stub
        int t;
        for(int i = 0;i < old.length-1;i++){
            for(int j = i+1;j < old.length;j++){
                if(old[i] > old[j]){
                    t = old[i];
                    old[i] = old[j];
                    old[j] = t;
                }
            }
        }

        return old;
    }

}


/**
 * 简单选择排序
 * */
public class SimpleSelectSort implements OnSort{

    @Override
    public int[] sort(int[] old) {
        // TODO Auto-generated method stub
        int min;
        int k,t;
        for(int i = 0;i < old.length-1;i++){
            min = old[i];
            k = -1;
            for(int j = i+1;j < old.length;j++){
                if(min > old[j]){
                    min = old[j];
                    k = j;
                }
            }
            if(k != -1){
                t = old[i];
                old[i] = old[k];
                old[k] = t;
            }
        }

        return old;
    }

}

运行结果如下：

public class Client {

    private static OnSort onSort = null;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = {1,40,5,8,6,55,13};

        onSort = new BubbleSort();
        a = onSort.sort(a);
        System.out.println("冒泡排序:");
        for(int i = 0;i < a.length;i++){
            System.out.print(String.valueOf(a[i]) + "  ");
        }

        int[] b = {1,40,5,8,6,55,13};
        onSort = new SimpleSelectSort();
        b = onSort.sort(b);
        System.out.println("\n简单选择排序:");
        for(int i = 0;i < b.length;i++){
            System.out.print(String.valueOf(b[i]) + "  ");
        }
    }

}


//output
冒泡排序:
1  5  6  8  13  40  55  
简单选择排序:
1  5  6  8  13  40  55 

　　可以发现，在两次对于相同数组（这里使用数值相同的a,b两个数组）排序时，采用不同的排序算法得到的结果是一样的。代码的不同也仅仅是对于接口 OnSort 实例化时不同。
　
　　
　　意义：策略模式很好的对操作进行了封装，对于定义的抽象功能注入了不同的实现，达到了很好的扩展性。