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

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

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

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

执行方式可以自由切换：

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

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

避免使用多重条件判断：

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

扩展性良好：

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

缺点其实显而易见：

• 1.策略类数量增多

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

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

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

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

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

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

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

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

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

有N多个策略怎么办？

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

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

总结

到此这篇关于Java 策略模式 if-else用法详解的文章就介绍到这了,更多相关Java if-else内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！