Java 策略模式 if-else用法实例详解

引言：

策略模式

comparable接口

comparator接口

不同的排序策略实现

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

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

有N多个策略怎么办？

总结

引言：

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

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

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

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

策略模式 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逼格高了一些呢，^_^

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

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