作者：行百里er

博客：https://chendapeng.cn (opens new window)

提示

这里是 行百里er 的博客：行百里者半九十，凡事善始善终，吾将上下而求索！

策略模式

引言：

公司要扩大规模，目前需要购买一批汽车，还要招聘一批保安，老板指示暂时只想看新车，只需要给他看按照价格排好序的新车列表就行；保安候选人按照安保工作经验排好序给他一个列表。

汽车数据，还有保安候选人的数据已经放在了程序员的面前，你只需要给我个列表就好了。

基于这个需求，我们自然而然的会想到排序啊。

开始之前，我们先来看一下jdk中的comparable接口和comparator接口,可参考 文档描述 (opens new window)

comparable接口

java.lang Interface Comparable

T - the type of objects that this object may be compared to（可以与之比较的对象的类型）

需要实现的方法

int compareTo(T o)

参数:

o - 要比较的对象

返回:

当此对象小于指定的对象时返回负整数，等于返回0，大于返回正整数

我们写Car类和SecurityMan类，让他们都实现Comparable接口

汽车按价格排序

public class Car implements Comparable<Car> {

    //价格
    private int price;
    //油箱容量
    private int capacity;

    public Car(int price, int capacity) {
        this.price = price;
        this.capacity = capacity;
    }

    @Override
    public int compareTo(Car c) {
        if (this.price < c.price) {
            return -1;
        }
        if (this.price > c.price) {
            return 1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Car{" +
                "price=" + price +
                ", capacity=" + capacity +
                '}';
    }
}

保安按工作经验排序

public class SecurityMan implements Comparable<SecurityMan> {

    //安保经验
    private int experience;
    //颜值
    private int beauty;

    public SecurityMan(int experience, int beauty) {
        this.experience = experience;
        this.beauty = beauty;
    }

    @Override
    public int compareTo(SecurityMan o) {
        if (this.experience < o.experience) {
            return -1;
        }
        if (this.experience > o.experience) {
            return 1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "SecurityMan{" +
                "experience=" + experience +
                ", beauty=" + beauty +
                '}';
    }
}

再来一个Context类，来封装对那些对象进行比较的类

public class Context {

    public void sortCar(Car[] cars) {
        for (int i = 0; i < cars.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < cars.length; j++) {
                minIndex = cars[i].compareTo(cars[j]) > 0 ? j : minIndex;
            }
            Car c = cars[i];
            cars[i] = cars[minIndex];
            cars[minIndex] = c;
        }
    }

    public void sortSecurityMan(SecurityMan[] men) {
        for (int i = 0; i < men.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < men.length; j++) {
                minIndex = men[i].compareTo(men[j]) > 0 ? j : minIndex;
            }
            SecurityMan c = men[i];
            men[i] = men[minIndex];
            men[minIndex] = c;
        }
    }

}

那么问题来了，如果老板想要看汽车容量排序怎么办？要看保安颜值排序怎么办？

对于Car类，我们可以加一个属性，比如sortBy，在compareTo方法中加if-else，根据sortBy的值进行不同的排序，而且Context类中也要加对应的方法。

这样的话，后续如果你加更多的排序，就需要修改多处代码，这酸爽。。。

我如果想要对一个对象进行比较的策略能够灵活的指定，这才是最好的！！！

comparator接口

java.util Interface Comparator

T - the type of objects that may be compared by this comparator（比较器可以比较的对象类型）

方法

int compare(T o1, T o2)

参数:

o1 - 第一个需要排序的对象

o2 - 第二个需要排序的对象

返回:

第一个需要排序的对象如果小于、等于、大于第二个对象，返回负整数，0，正整数

不同的排序策略实现

我们用Comparator接口来实现各种排序策略。

策略1：对汽车按照价格排序

public class CarPriceComparator implements Comparator<Car> {

    @Override
    public int compare(Car o1, Car o2) {
        if (o1.price < o2.price) return -1;
        else if (o1.price > o2.price) return 1;
        return 0;
    }
}

策略2：对汽车按照容量排序

public class CarCapacityComparator implements Comparator<Car> {

    @Override
    public int compare(Car o1, Car o2) {
        if (o1.capacity > o2.capacity) return -1;
        else if (o1.capacity < o2.capacity) return 1;
        return 0;
    }
}

策略3：对保安按照工作经验排序

public class SecurityManExperienceComparator implements Comparator<SecurityMan> {

    @Override
    public int compare(SecurityMan o1, SecurityMan o2) {
        if (o1.experience < o2.experience) return -1;
        else if (o1.experience > o2.experience) return 1;
        return 0;
    }
}

策略4：对保安按照颜值排序

public class SecurityManBeautyComparator implements Comparator<SecurityMan> {

    @Override
    public int compare(SecurityMan o1, SecurityMan o2) {
        if (o1.beauty < o2.beauty) return -1;
        else if (o1.beauty > o2.beauty) return 1;
        return 0;
    }
}

这时我们的Context就可以为所欲为了，你想要对谁排序就可以对谁排序，只要你有相应的排序策略就可以。

Context策略切换上下文：

public class Context<T> {

    private Comparator comparator;

    public Context(Comparator comparator) {
        this.comparator = comparator;
    }

    public void sortWhatYouWant(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = this.comparator.compare(arr[i], arr[j]) > 0 ? j : minIndex;
            }
            T o = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = o;
        }
    }
}

Client-相当于老板，老板想要什么排序策略，直接调起Context切换策略：

public class Client {

    public static void main(String[] args) {
        Car[] cars = {new Car(18, 55), new Car(12, 40), new Car(25, 60)};

        SecurityMan[] men = {new SecurityMan(10, 95), new SecurityMan(6, 92), new SecurityMan(8, 97)};

//        Context ctx = new Context(new CarCapacityComparator());
        Context ctx = new Context(new SecurityManBeautyComparator());
        ctx.sortWhatYouWant(men);
        System.out.println(Arrays.toString(men));
    }
}

这种写法是不是比if-else逼格高了一些呢，^_^

这其实就是策略模式，他很好滴践行了 对修改关闭，对扩展开放的设计原则。

总结一下，我们上面实现的策略模式类图：

策略模式比if-else香在哪呢？有缺点吗？

真香：

• 执行方式可以自由切换

比如我们上面举的例子，可以对排序策略进行自由的切换。

执行方式可以自由切换是策略模式本身定义的，只要实现抽象策略，它就成为策略家族的一个成员，通过封装角色对其进行封装，保证对外提供“可自由切换”的策略

• 避免使用多重条件判断

就我们的例子而言，两个类，每个类都有可排序的两个属性，如果分别按照各自的属性排序，得写多少if-else啊！！！

• 扩展性良好

扩展性当然良好。一个具体的策略很好实现啊。

缺点其实显而易见：

• 策略类数量增多

每一个策略都是一个类，复用的可能性很小，类数量增多。

• 所有的策略类都需要对外暴露

每有一个策略，都得告诉别人一下，否则老板也不知道你能不能给我满足我的要求。

也就是说上层模块必须知道有哪些策略，然后才能决定使用哪一个策略，那么我只是想使用了一个策略，我凭什么就要了解这个策略呢？那要你的封装类还有什么意义？

策略模式有哪些使用场景呢？

• 多个类只有在算法或行为上稍有不同的场景
• 算法需要自由切换的场景

例如，算法的选择是由使用者决定的，或者算法始终在进化，特别是一些站在技术前沿的行业，连业务专家都无法给你保证这样的系统规则能够存在多长时间，在这种情况下策略模式是你最好的助手。

• 需要屏蔽算法规则的场景

现在的科技发展得很快，人脑的记忆是有限的（就目前来说是有限的），太多的算法你只要知道一个名字就可以了，传递相关的数字进来，反馈一个运算结果，万事大吉。

我有N多个策略怎么办？

如果系统中的一个策略家族的具体策略数量超过4个，则需要考虑使用混合模式，解决策略类膨胀和对外暴露的问题，否则日后的系统维护就会成为一个烫手山芋，谁都不想接。

针对策略模式的缺点，我们可以使用其他模式来修正这个缺陷，如工厂方法模式、代理模式或享元模式等。

---

首发公众号 行百里er ，欢迎老铁们关注阅读指正。

首发公众号 行百里er ，欢迎老铁们关注阅读指正。代码仓库 GitHub github.com/ChenDapengJava (opens new window)