设计模式：策略模式

【实验内容和要求】
某系统提供了一个用于对数组数据进行操作的类，该类封装了对数组的常见操作，如查找数组元素、对数组元素进行排序等。现以排序操作为例，使用策略模式设计该数组操作类，使得客户端可以动态地更换排序算法，可以根据需要选择冒泡排序或选择排序或插入排序，也能够灵活地增加新的排序算法。

【实验目的】

1. 掌握策略模式（Strategy）的特点
2. 分析具体问题，使用策略模式进行设计。

【模式UML图】

【模式代码】

//策略模式的接口：调度排序算法
public interface Sort {
    public int[] sort(int[] arr);
}

//插入排序
public class InsertionSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            // 寻找元素 arr[i] 合适的插入位置
            for( int j = i ; j > 0 ; j -- ) {
                if (arr[j]<(arr[j - 1])) {
                    swap(arr, j, j - 1);
                } else {
                    break;
                }
            }
        }
        return arr;
    }

    private void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

//选择排序
public class SelectionSort implements Sort{
    @Override
    public int[] sort(int[] arr) {
        int min,temp;
        for (int i = 0; i < arr.length-1; i++) {
            min=i;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i] > arr[j]) { //寻找最小数
                    min = j;   //最小数索引
                }
            }
            //交换两个位置
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
        return arr;
    }

}

//冒泡排序
public class BubbleSort implements Sort{
    @Override
    public int[] sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
}

//策略环境类
public class ArrayHandler {
    private Sort sortObj;

    public void setSort(Sort sort) {
        this.sortObj = sort;
    }

    public int[] sort(int[] arr){
        sortObj.sort(arr);
        return arr;
    }
}

public class Client {
    public static void main(String[] args) {
        int [] arr1={5,8,67,6,3,4};
        int [] arr2={5,8,34,6,3,4};
        int [] arr3={5,8,1,6,3,4};
        //生成一个策略环境类
        ArrayHandler handlerSort=new ArrayHandler();

        //生成策略
        Sort sort1,sort2,sort3;
        sort1=new BubbleSort();
        sort2=new SelectionSort();
        sort3=new InsertionSort();

        //冒泡排序
        handlerSort.setSort(sort1);
        System.out.println("排序前："+Arrays.toString(arr1));
        handlerSort.sort(arr1);
        System.out.println("排序后："+Arrays.toString(arr1));

        //选择排序
        handlerSort.setSort(sort2);
        System.out.println("排序前："+Arrays.toString(arr2));
        handlerSort.sort(arr2);
        System.out.println("排序后："+Arrays.toString(arr2));

        //插入排序
        handlerSort.setSort(sort3);
        System.out.println("排序前："+Arrays.toString(arr3));
        handlerSort.sort(arr3);
        System.out.println("排序后："+Arrays.toString(arr3));

    }
}

【运行截图】

【实验小结】

通过本次实验，学会了使用策略模式。策略模式的适用性如下：
1、许多相关的类仅仅是行为有异；
2、需要使用一个算法的不同变体；
3、算法使用客户不应该知道的数据；
4、一个类定义了多种行为，并且这些行为在类的操作中以多个条件语句的形式出现。