【设计模式】16.行为型模式-策略（Strategy）

一、描述

　　定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

　　1.角色

　　　　(1)抽象类：定义算法方法。

　　　　(2)具体实现类：继承抽象类，实现算法方法。

　　2.类图

二、

以快速排序算法、合并排序算法为例，类图很简单，和上面的类图差不多，所以就不画了。直接上代码：

　　1.抽象计算类

public interface Calculate {
    void order(int[] values);
}

　　2.快速排序算法(想了解该算法的话参考文章：算法-快速排序)

public class FastSortCalculate implements Calculate {
    @Override
    public void order(int[] values) {
        int left = 0;
        int right = values.length - 1;
        sort(values, left, right);
        System.out.println("快速排序："); for (int i = 0; i < values.length; i++) { System.out.print(" " + values[i]); } System.out.println(); } private void sort(int[] a, int left, int right) { if (left > right) { return; } int i = left; int j = right; int sign = a[left]; while (i != j) { //查找比sign小的元素位置 while (a[j] >= sign && i < j) { j--; } //查找比sign大的元素位置 while (a[i] <= sign && i < j) { i++; } //交换 if (i < j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } } //相遇或者遇到(8)(10)(11)等情况，直接交换 a[left] = a[j]; a[j] = sign; //分割数组重新排序 sort(a, left, j - 1); sort(a, j + 1, right); } }

　　3.合并排序算法(想了解该算法的话参考文章：算法-合并排序)

public class MergeSortCalculate implements Calculate {
    @Override
    public void order(int[] values) {
        //定义下标
        int right = values.length - 1;
        int left = 0;
        int[] b = new int[values.length]; mergeSort(values, b, left, right); //合并 System.out.println("合并排序："); for (int i = 0; i < b.length; i++) { System.out.print(" " + b[i]); } System.out.println(); } public static void mergeSort(int[] a, int[] b, int left, int right) { if (left == right) { //分到最小单位 return; } if (left < right) { //当未拆分完时继续拆分 int mid = (left + right) / 2; //分组  mergeSort(a, b, left, mid); mergeSort(a, b, mid + 1, right); //拆分完合并 //i定义为左边数组起点 int i = left; //i定义为右边数组起点 int j = mid + 1; //新数组下标 int t = 0; //当前两边数组未排序完成时 while (i <= mid && j <= right) { //定义min接收较小数据 int min; if (a[i] < a[j]) { //若当前左边数组i位置上的数据小于右边数组j位置上的数据，说明右边数组j后面位置的数据都大于i对应的数据， // 所以i++向后移动比较下一个左边数组的数据与当前右边数据j的数据。 min = a[i]; i++; } else { //若左边数组i位置上的数据大于j位置上的数据，则i位置要继续与右边数组剩下的数据进行比较，j++ min = a[j]; j++; } //将较小数据放到b数组对应位置上，并且下标向后移动一位 b[t++] = min; } //若左边数组上还有剩余数据，则放到数组中 while (i <= mid) { b[t++] = a[i++]; } //若右边数组上还有剩余数据，则放到数组中 while (j <= right) { b[t++] = a[j++]; } //将b数组中的有序数组放到a对应的位置上。 t = 0; while (left <= right) { a[left++] = b[t++]; } } } }

　　4.调用

public class Client {
    public static void main(String[] args) {
        int[] a = {9, 5, 2, 7, 12, 4, 3, 1, 11};
        Calculate fastSortCalculate = new FastSortCalculate();
        fastSortCalculate.order(a);

        Calculate mergeSortCalculate = new MergeSortCalculate(); mergeSortCalculate.order(a); } }

　　5.效果