设计模式学习总结(十五)--策略模式

定义

策略模式就是定义了算法族，将其分别封装起来，让他们之前可以互相转换，策略模式让该算法的变化独立于使用算法的客户。

在软件系统中有很多种方法可以实现同一个功能，比如排序算法它有冒泡排序、选择排序、快速排序、插入排序等等。这里我们有一种硬编码方法，就是将所有的排序算法全部写在一个类中，每一种算法的具体实现对应着一个方法，然后写一个总方法通过 if…else… 来判断选择具体的排序算法，但是这样做存在几个问题。

• 如果需要增加新的算法，则需要修改源代码。

• 如果更新了排序算法，那么需要在客户端也需要修改代码，麻烦。

• 充斥着大量的if…else…语句，代码维护比较困难。

所以为了解决这些问题，我们可以定义一些独立的类来封装不同的算法，每一个独立的类对应着一个具体的算法实现，在这里我们就将这里每一个独立的类称之为一个策略。

实例

未使用策略模式前代码

public void selectSort(String type){
    if("type1".equals(type)){
        //选择快速排序
    }
    else if("type2".equals(type)){
        //选择插入排序
    }
    else if("type3".equals(type)){
        //选择冒泡排序
    }
    else if("type4".equals(type)){
        //选择选择排序
    }
}

定义排序接口：

public interface Sort {
    int[] sort(int arr[]);
}

排序接口具体实现类：

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


/**
 * 插入排序
 */
public class InsertionSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        System.out.println("插入排序");
        int len = arr.length;
        for (int i = 1; i < len; i++) {
            int j;
            int temp = arr[i];
            for (j = i; j > 0; j--) {
                if (arr[j - 1] > temp) {
                    arr[j] = arr[j - 1];

                } else
                    break;
            }
            arr[j] = temp;
        }
        return arr;
    }
}

/**
 * 选择排序
 */
public class SelectionSort implements  Sort {
    @Override
    public int[] sort(int[] arr) {
        System.out.println("选择排序");
        int len = arr.length;
        int temp;
        for (int i = 0; i < len; i++) {
            temp = arr[i];
            int j;
            int samllestLocation = i;
            for (j = i + 1; j < len; j++) {
                if (arr[j] < temp) {
                    temp = arr[j];
                    samllestLocation = j;
                }
            }
            arr[samllestLocation] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }
}

排序处理类：

public class SortHandler {

    private Sort sortObj;

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

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

测试：

 public static void main(String[] args) {
     int arr[] = {1, 4, 6, 2, 5, 3, 7, 10, 9};
     SortHandler ah = new SortHandler();
     // 冒泡排序
     ah.setSortObj(new BubbleSort());
     outPrint(ah.sort(arr));
     // 选择排序
     ah.setSortObj(new SelectionSort());
     outPrint(ah.sort(arr));
 }

 private static void outPrint(int[] result) {
     for (int i = 0; i < result.length; i++) {
         System.out.print(result[i] + ",");
     }
     System.out.println();
 }

控制台输出：

冒泡排序
1,2,3,4,5,6,7,9,10,
选择排序
1,2,3,4,5,6,7,9,10,

转载于:https://www.cnblogs.com/markLogZhu/p/11582643.html