淺談Strategy策略模式

1、前言

下面咱們看一下策略模式，策略模式其實比較簡單，相信你們都使用過，只不過不清楚而已，其實就是使用抽象類或者接口，定義一個方法，而後子類來實現響應的方法，以後經過一個新的類來使用這個已經定義好的組件，使用委託的方式，讓定義好的接口根據多態來靈活的使用相應的實現方法，最終完成必定的功能。而Builder模式比起來，Builder中新建的類還要對接口中的元素方法進行組合和操做，而策略模式只用一個方法就能夠，沒有這種複雜的操做，就是簡單的使用已定義好的方法，不用再次封裝操做。和橋接模式相比，差異也是很明顯的，橋接是功能層次和實現層次分離，而策略模式是方便擴充策略，可是這幾種模式的某些部分是很相似的，只不過完成的任務有些不一樣而已。

2、代碼

package designMode.strategy;

public interface Sorter {
    public abstract void sort(Comparable[] data);
}

package designMode.strategy;

public class BubbleSorter implements Sorter {
    @Override
    public void sort(Comparable[] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data.length; j++) {
                if(data[i].compareTo(data[j])>0){
                    Comparable temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }
        }
    }
}

package designMode.strategy;

public class QuickSorter implements Sorter{
    @Override
    public void sort(Comparable[] data) {
        int low=0,high=data.length-1;
        Qsort(data,low,high);
    }

    private int Partition(Comparable[] data,int low,int high){
        Comparable temp,pivotkey;
        pivotkey=data[low];//選取支點
        temp=pivotkey;//暫存支點
        if (low<high){
            if (data[high].compareTo(pivotkey)>=0){
                high--;//左移
            }
            data[low]=data[high];
            if(data[low].compareTo(pivotkey)<=0){
                low++;//右移
            }
            data[high]=data[low];//覆蓋
        }
        data[low] = temp;
        return 1;
    }

    private void Qsort(Comparable[] data,int low,int high){
        int pivot;
        if(low<high){
            pivot=Partition(data,low,high);//獲取分界點位置
            Qsort(data,low,pivot-1);//排左邊
            Qsort(data,pivot+1,high);//排右邊
        }
    }
}

package designMode.strategy;

public class SortAndPrint {
    private Comparable[] data;
    private Sorter sorter;

    public SortAndPrint(Comparable[] data, Sorter sorter) {
        this.data = data;
        this.sorter = sorter;
    }

    public void execuate(){
        printResult();
    }

    private void printResult() {
        System.out.println("===================");
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]+" ");
        }
        System.out.println("====================");
    }

}

package designMode.strategy;

public class Main {
    public static void main(String[] args) {
        Comparable[] data1={"jsy","sxn","love","forever"};
        SortAndPrint sap1 = new SortAndPrint(data1,new QuickSorter());
        System.out.println("=====策略一=====");
        sap1.execuate();
        System.out.println("=====策略二=====");
        Comparable[] data2 = {"jsy","sxn","love","forever"};
        SortAndPrint sap2 = new SortAndPrint(data2,new BubbleSorter());
        sap2.execuate();
    }
}

3、總結

從代碼中咱們能夠看到沒有什麼新的元素加入，當咱們使用一種方法的時候，這種方法有不少實現方式，好比說加密算法，能夠有MD五、SHA一、RSA等等，對於這些算法，咱們若是一個個實現就會變得很是的差勁，特別是對於調用方，直接使用某種方法是一種大忌，由於之後要使用別的還須要修改，這破壞了代碼的封裝性，所以，咱們不推薦這樣作，所以就有了這個策略模式，能夠很方便的進行策略的擴充，而不須要修改原有的代碼。

 

淺談設計模式<最通俗易懂的講解>