设计模式(4)——策略模式

策略模式

定义：策略模式对某一个问题，有多种不同的算法，并将每个算法独立的封装起来。它们之间可以相互替换，此模式使得算法的变换不会影响到最终得到的结果。
优点：

1. 避免了if-else的使用，（如果不用策略模式我们可能会使用多重条件语句，不利于维护）
2. 遵循开闭原则，扩展性好，实现代码的解耦合。扩展新的算法时，只需要增加类实现接口，不需要修改源核心业务代码。
3. 遵循单一职责，每个算法子类只完成一项工作。

缺点：

1. 所有的策略类都需要对外暴露，客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2. 策略模式会出现很多的策略类，复用的可能性很小

适用场景：达成一个目的可以有多种方法。多种方法之间可以相互替换，仅供用户选择。选择不同的方式产生的结果都是一样的

模式结构：
策略模式包含如下角色：

• 环境类：使用算法的角色，是连接用户类和算法子类之间的桥梁。
• 抽象策略类：为一类算法声明了抽象方法，所有策略类的父类，可以是抽象类，也可以是接口。
• 具体策略类：实现了抽象策略类的方法，包含某种算法的实现。

模式结构图如下：

模式代码实例：
1、线上支付
2、排序选择
这里演示排序选择代码可以更为清晰理解策略模式

抽象策略类 Sort

/**
 *抽象排序类
 */
public abstract class Sort {
    public abstract int[] sort(int []nums);
}

具体策略类

BubbleSort

/**
 * 冒泡排序类
 */
public class BubbleSort extends Sort {
    @Override
    public int[] sort(int[] a) {
        for(int i=0;i<a.length;i++) {
            boolean flag=true;
            for(int j=0;j<a.length-i-1;j++) {
                if(a[j]>a[j+1]) {
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=false;
                }
            }
            if(flag) {
                break;
            }
        }
        return a;
    }
}

QuickSort

/**
 * 快速排序类
 */
public class QuickSort extends Sort {
    @Override
    public int[] sort(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;
    }
    public void quickSort(int []a,int lid,int rid){
        int i=lid;
        int j=rid;
        if(i>j) {
            return ;
        }
        boolean flag=true;
        while(i!=j) {
            if(a[i]>a[j]) {
                int tmp=a[i];
                a[i]=a[j];
                a[j]=tmp;
                flag=!flag;
            }
            if(flag) {
                j--;
            }
            else {
                i++;
            }
        }
        i--;
        j++;
        quickSort(a,lid,i);
        quickSort(a,j,rid);
    }
}

环境类

ArrayHandler

/**
 * 环境类
 */
public class ArrayHandler {
    private Sort sortObj;
    //用户选定策略
    public void setObj(Sort sortObj) {
        this.sortObj=sortObj;
    }
    //根据选定的策略进行排序
    public int[] sort(int []nums)
    {
        return sortObj.sort(nums);
    }
}

测试类

/**
 * 测试类
 */
public class TestSort {
    public static void main(String[] args) {
        int []nums={12,15,4,9,7};
        //创建一个桥梁
        ArrayHandler handler=new ArrayHandler();
        //选定策略
        //Sort sort=new BubbleSort();
        Sort sort=new QuickSort();
        handler.setObj(sort);
        //进行排序
        handler.sort(nums);
        for(int s: nums)
        {
            System.out.print(s+" ");
        }
        //测试结果如下
        //4 7 9 12 15 
    }
}

参考书籍：
设计模式.刘伟.胡志刚.郭克华.清华大学出版社