设计模式---策略模式

1.小需求引出

一批宠物，需要根据其特征进行排序

猪：根据吃的多少排序
狗：根据叫的分贝排序
猫：根据体重进行排序
如果让你实现，你会怎么实现

初步实现

创建三个类

猪：public class Pig {…}

狗：public class Dog {…}

猫：public class Cat {…}

创建一个Sorter类，包含三个方法

第一个方法：public void pigSort(Pig[] array) {…}

第二个方法：public void dogSort(Pig[] array) {…}

第三个方法：public void catSort(Pig[] array) {…}

测试类

public class Main {
    public static void main(String[] args) {
        Dog[] array = new Dog[]{new Dog(3), new Dog(1), new Dog(2)};
        Sorter sorter = new Sorter();
        sorter.dogSort(array);
        for (Dog dog : array) {
            System.out.print(dog + " ");
        }
    }
}

想几个问题

如果我现在有上千批宠物，每一个宠物都弄一个Sort方法吗？
如果我每一个宠物都有2种特征，分别排序，是不是还要给我写一个方法？
代码的可扩展性、可维护性有吗？

策略模式下的实现

策略模式最大的优点就是避免了大规模的if else 判断

策略模式有一个公共的 Strategy 接口，通过该接口，封装着实现同一种事情的不同方法

我们首先要创建一个公共接口，名字叫 Comparator，作为我们所有宠物排序的公共接口

public interface Comparator<T> {
    int compare(T o1, T o2);
}

实现公共接口的三个实现类(这里只写猫的，其他类似)：

public class CatWeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if (o1.weight > o2.weight) {
            return 1;
        } else if (o1.weight < o2.weight) {
            return -1;
        } else {
            return 0;
        }
    }
}

实现我们的主要类：Sorter
主函数只需要告知 Sorter 我们当前使用的哪个数组及哪个实现类既可以完成排序

public class Sorter<T> {
    // arrry：传进来的数组
    // comparator：比较器的类型
    public void sort(T[] array, Comparator<T> comparator) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (comparator.compare(array[j], array[j + 1]) > 0) {
                    T temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

总结

我们观察如上的架构图可以发现，对于Sorter方法，我们从来不会更改其代码，当我们需要增添一个特征或者宠物时，我们采取的是增加一个实现类的操作无论有多少宠物、多少特征，我们只需要在容器内增加实现类，让外部Sorter调用即可，极大的增加了代码的可扩展性