浅谈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等等，对于这些算法，咱们若是一个个实现就会变得很是的差劲，特别是对于调用方，直接使用某种方法是一种大忌，由于之后要使用别的还须要修改，这破坏了代码的封装性，所以，咱们不推荐这样作，所以就有了这个策略模式，能够很方便的进行策略的扩充，而不须要修改原有的代码。

 

浅谈设计模式<最通俗易懂的讲解>