一、前言

  下面我们看一下策略模式，策略模式其实比较简单，相信大家都使用过，只不过不清楚而已，其实就是使用抽象类或者接口，定义一个方法，然后子类来实现相应的方法，之后通过一个新的类来使用这个已经定义好的组件，使用委托（组合）的方式，让定义的接口根据多态来灵活的使用相应的实现方法，最终完成一定的功能。和Builder模式比起来，Builder中新建的类还要对接口中的元素方法进行组合和操作，而策略模式只用一个方法就可以，没有这种复杂的操作，就是简单的使用已经定义好的方法，不用再次封装操作。和桥接模式相比，差别也是很明显的，桥接是功能层次和实现层次分离，而策略模式是方便扩充策略，但是这几种模式的某些部分是很类似的，只不过完成的任务有些许不同而已。

角色

Context 环境 Strategy 策略接口 ConcreteStrategyA ConcreteStrategyB Strategy2 策略接口 ConcreteStrategyC ConcreteStrategyD

UML类图

二、代码

Sorter 代码：

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

BubbleSorter 代码：

public class BubbleSorter implements Sorter{

    public void sort(Comparable[] data) {
        for(int i=0;i<data.length;i++){
            for(int j=i+1;j<data.length;j++){
                if(data[i].compareTo(data[j])>0)
                {
                    Comparable temp=data[i];
                    data[i]=data[j];
                    data[j]=temp;
                }
            }
        }
        
    }
    
}

QuickSorter  代码：

public class QuickSorter  implements Sorter{

    public void sort(Comparable[] data) {
        int low=0,high=data.length-1;
        Qsort(data, low, high) ;
    }
    /**************快速排序*****************/
    private int Partiton(Comparable[] data,int low,int high)
    {  
        Comparable temp,pivotkey;  
        pivotkey=data[low]; //选取支点
        temp=pivotkey;  //暂存支点
        while (low<high)  //条件，相等则结束
        {  
            while (low<high && data[high].compareTo(pivotkey)>=0)  
            {
                high--;//左移  
            }
            data[low]=data[high];//覆盖  
            while (low<high && data[low].compareTo(pivotkey)<=0)  
            {
                low++;  //右移
            }
            data[high]=data[low];//覆盖  
        }  
        data[low]=temp; //恢复
        return low;  //返回分界点位置
    }  
    private void Qsort(Comparable[] data,int low,int high)  
    {  
        int pivot;  
        if (low<high)  
        {  
            pivot=Partiton(data,low,high); //获得分界点位置
            Qsort(data,low,pivot-1); //排左边
            Qsort(data,pivot+1,high);//右边  
        }  
    }  

}

SortAndPrint代码：

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();
         sorter.sort(data);
         printResult();
    }
    public void printResult(){
        System.out.println("=========================");
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+"  ");
        }
        System.out.println("\n=========================");
    }
    
    

}

Main类：

public class Main {

    public static void main(String[] args) {

        Comparable []data1={"zyr","lsx","love","forever"};
        SortAndPrint sap1=new SortAndPrint(data1,new QuickSorter());
        System.out.println("=====策略一======");
        sap1.execuate();        
        System.out.println("=====策略二======");
        Comparable []data2={"zyr","lsx","love","forever"};
        SortAndPrint sap2=new SortAndPrint(data2,new BubbleSorter());
        sap2.execuate();

    }
}

运行结果：

• 注意事项和细节

  • 分析项目中变化部分与不变部分

  • 体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为） 即可

  • 策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展

注意：在很多场景中，策略接口会作为内部接口体现

• 应用

  • Arrays工具类的排序方法Comparator策略接口的使用

  • JDBC对Result结果集的处理

三、总结

  从代码中我们可以看到没有什么新的元素加入，当我们使用一种方法的时候，这种方法有很多实现方式，比如说加密算法，可以有MD5、SHA1、RSA等等，对于这些算法，我们如果一个个实现就会变得非常的差劲，特别是对于调用方（SortAndPrint），直接使用某种方法是一种大忌，因为以后要使用别的还需要修改，这破坏了代码的封装性，因此，我们不推荐这样做，因此就有了这个策略模式，可以很方便的进行策略的扩充，而不需要修改原有的代码。