策略模式

1、概述

定义一系列的算法，把每一个算法封装起来，并且使它们可相互替换。本模式使得算法与对象独立开来，算法可独立于使用它的客户而变化。

2、模式分析

当实现一个功能有多种算法或策略时，我们可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的查找算法，通过if…else…或者case等条件判断语句来进行选择。这两种实现方法我们都可以称之为硬编码，如果需要增加新的算法，或者需要修改已有算法；将修改大量代码。在这个算法类中封装了大量查找算法，该类代码将较复杂，维护较为困难。

我们将这些算法封装成一个一个类，在运行过程中，可以自由切换算法。

3、模式角色

策略接口（Strategy）：策略接口，声明策略算法；

具体策略类（ConcreteStrategy）：具体的策略实现类，实现策略接口中的具体算法；

使用某种策略的类（Context）：在该类中可以定义多种不同的具体策略类，在运行过程中根据不同的条件使用不同的策略类。

4、优点与缺点

优点：

• 算法可以自由切换；
• 避免了多重条件的判断；
• 扩展性良好

缺点：

具体的策略类较多，增加系统的复杂性。

5、应用示例

假设Context是个含有一个整型数组的类，为了测试不同排序算法的时间复杂度，需要在运行过程中调用不同的排序算法，现采用策略模式实现这一测试过程。简单起见，这里只介绍简单选择排序和冒泡排序。

ArraySortStrategy（数组排序策略接口）

/**
 * 数组排序策略接口
 * @author hjy
 */
public interface ArraySortStrategy {

    /**
     * 对数组进行排序，返回比较的次数
     * @param arr
     * @return
     */
    public int sort(int[] arr);
}

SimpleSelectSortStrategy（简单选择排序策略）

/**
 * 简单选择排序策略
 * @author hjy
 */
public class SimpleSelectSortStrategy implements ArraySortStrategy {

    @Override
    public int sort(int[] arr) {
        int size = arr.length;
        int count = 0;
        
        for(int i = 0; i < size - 1; i++){
            int max_index = i;
            //选择出最大值的索引位置
            for(int j = i + 1; j < size; j++){
                if(arr[j] > arr[max_index]){
                    count++;
                    max_index = j;
                }
            }
            //交换位置
            if(max_index != i){
                int temp = arr[i]; arr[i] = arr[max_index]; arr[max_index] = temp;
            }
        }
        return count;
    }
}

BubbleSortStrategy（冒泡排序策略）

/**
 * 冒泡排序策略
 * @author hjy
 */
public class BubbleSortStrategy implements ArraySortStrategy {
    @Override
    public int sort(int[] arr) {
        int size = arr.length;
        int count= 0;
        
        for(int i = 0; i < size - 1; i++){
            for(int j = 0; j < size - i -1; j++){
                if(arr[j] < arr[j+1]){
                    count++;
                    int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp;
                }
            }
        }
        return count;
    }
}

ArraySortContext（使用不同策略的类）

/**
 * 使用不同排序策略的类
 * @author hjy
 */
public class ArraySortContext {
    //策略成员类
    private ArraySortStrategy sortStrategy;
    
    //set方法，指定不同的策略
    public void setSortStrategy(ArraySortStrategy sortStrategy){
        this.sortStrategy = sortStrategy;
    }
    
    //执行策略
    public void execSort(int[] arr){
        int count = sortStrategy.sort(arr);
        System.out.println("比较次数：" + count);
    }
}

ArraySortClient（客户端）

public class ArraySortClient {
    public static void main(String[] args) {
        int[] arr1 = new int[20];
        int[] arr2 = new int[20];
        Random random = new Random();
        for(int i = 0; i < 20; i++){
            int num = random.nextInt(100) + 1;
            arr1[i] = num;
            arr2[i] = num;
        }
        
        //定义简单选择排序策略
        ArraySortStrategy simpleSelectSortStrategy = new SimpleSelectSortStrategy();
        //定义冒泡排序策略
        ArraySortStrategy bubbleSortStrategy = new BubbleSortStrategy();
        
        //定义使用不同排序策略的类
        ArraySortContext context = new ArraySortContext();
        
        //使用简单排序策略来进行排序
        context.setSortStrategy(simpleSelectSortStrategy);
        context.execSort(arr1);
        print(arr1);
        
        //使用冒泡排序策略来进行排序
        context.setSortStrategy(bubbleSortStrategy);
        context.execSort(arr2);
        print(arr2);
    }
    
    private static void print(int[] arr){
        StringBuffer strBuffer = new StringBuffer();
        for(int i = 0; i < arr.length; i++){
            if(i == arr.length - 1){
                strBuffer.append(arr[i]);
            }else{
                strBuffer.append(arr[i]).append(", ");
            }
        }
        System.out.println(strBuffer.toString());
    }
}

结果：

比较次数：34
100, 95, 93, 86, 83, 82, 80, 80, 74, 62, 60, 58, 56, 53, 46, 44, 29, 17, 14, 7
比较次数：82
100, 95, 93, 86, 83, 82, 80, 80, 74, 62, 60, 58, 56, 53, 46, 44, 29, 17, 14, 7