目录
- 引言：
- 策略模式
- 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个，则需要考虑使用混合模式，解决策略类膨胀和对外暴露的问题，否则日后的系统维护就会成为一个烫手山芋，谁都不想接。
针对策略模式的缺点，我们可以使用其他模式来修正这个缺陷，如工厂方法模式、代理模式或享元模式等。
评论(0)