前言
软件开发中，经常遇到一种情况：实现一个功能可以有多种算法或策略，我们根据实际情况选择不同的算法或者策略来完成该功能。
针对这种情况，常规实现方法是将多种算法写在一个类中，然后通过if-else或者switch-case等条件语句来选择具体的算法，但是当很多个算法集中在一个类时，这个类就会变得臃肿，维护成本变高，另外当我们想增加一种算法，或者想修改其中某一算法时，需要修改这个类的源代码，容易引发错误。这就明显违反了开闭原则和单一职责原则。这种情况下可以考虑使用策略模式。
感谢《Android源码设计模式解析与实战》！
策略模式的定义
策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
策略模式的使用场景
- 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。
- 需要安全地封装多种同一类型的操作时。
- 出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时。
策略模式的UML类图
- Context: 用来操作策略的上下文环境。
- Stragety: 策略的抽象。
- ConcreteStragetyA、ConcreteStragetyB: 具体的策略实现。
策略模式的简单示例
我们以交通工具为例，分别计算一下公交车和地铁的价格。公交车和地铁的计费方式分别对应不同的算法。
- 普通实现
public class PriceCalculator {
//公交车类型
private static final int BUS = 1;
//地铁类型
private static final int SUBWAY = 2;
public static void main(String[] args) {
PriceCalculator calculator = new PriceCalculator();
System.out.println("坐20公里的公交车票价为： " + calculator.calculatePrice(20, BUS));
System.out.println("坐20公里的地铁票价为： " + calculator.calculatePrice(20, SUBWAY));
}
//计算价格
private int calculatePrice(int km, int type) {
if (type == BUS) {
return busPrice(km);
} else if (type == SUBWAY) {
return subwayPrice(km);
}
return 0;
}
/**
* 北京公交车，十公里之内一元钱，超过十公里之后，每五公里加一元。
*
* @param km 公里
* @return
*/
private int busPrice(int km) {
//超过十公里的总距离
int extraTotal = km - 10;
//超过的距离是5公里的倍数
int extraFactor = extraTotal / 5;
//超过的距离对5公里取余
int fraction = extraTotal % 5;
//价格计算
int price = 1 + extraFactor * 1;
return fraction > 0 ? ++price : price;
}
/**
* 6公里（含）内3元；6~12公里（含）4元；12~22公里（含）5元；22~32公里（含）6元
*
* @param km
* @return
*/
private int subwayPrice(int km) {
if (km <= 6) {
return 3;
} else if (km > 6 && km <= 12) {
return 4;
} else if (km > 12 && km <= 22) {
return 5;
} else if (km > 22 && km <= 32) {
return 6;
}
//其他距离简化为7元；
return 7;
}
}
以上示例中，PriceCalculator类中承担了计算公交车和地铁乘坐价格的职责，并且通过if-else的形式来判断使用哪种计算方式，很明显违反了单一职责原则。
如果此时增加出行方式出租车，大致代码如下：
public class PriceCalculator {
//公交车类型
private static final int BUS = 1;
//地铁类型
private static final int SUBWAY = 2;
//出租车类型
private static final int TAXI = 3;
//计算价格
private int calculatePrice(int km, int type) {
if (type == BUS) {
return busPrice(km);
} else if (type == SUBWAY) {
return subwayPrice(km);
} else if (type == TAXI) {//**增加了判断**
return taxiPrice(km);
}
return 0;
}
/**
* 假设每公里2元
*
* @param km
* @return
*/
private int taxiPrice(int km) {//**增加了计算方式**
return km * 2;
}
}
可以看出，当我们每增加一种出行方式时，都需要在PriceCalculator中增加一个方法来计算该方式的出行价格，并在calculatePrice中进行判断，大量重复使用if-else。另外当计算方式发生变化时，需要直接在PriceCalculator类中进行修改，很可能一段代码是其他几个计算方式公用的，这就容易引起错误。在应对变化时，这类代码必然先得臃肿，难以维护。策略模式就很好的解决了以上问题。
- 策略模式实现
定义一个抽象的计算乘车价格的接口。
public interface CalculateStrategy {
/**
* 按距离计算价格
*
* @param km 公里
* @return 返回价格
*/
int calculatePrice(int km);
}
每一种出行方式都对应一个独立的计算策略类，这些策略类都实现了CalculateStrategy接口。
//公交价格计算策略
public class BusStrategy implements CalculateStrategy {
/**
* 北京公交车，十公里之内一元钱，超过十公里之后，每五公里加一元。
*
* @param km 公里
* @return
*/
@Override
public int calculatePrice(int km) {
//超过十公里的总距离
int extraTotal = km - 10;
//超过的距离是5公里的倍数
int extraFactor = extraTotal / 5;
//超过的距离对5公里取余
int fraction = extraTotal % 5;
//价格计算
int price = 1 + extraFactor * 1;
return fraction > 0 ? ++price : price;
}
}
//地铁价格计算策略
public class SubwayStrategy implements CalculateStrategy {
/**
* 6公里（含）内3元；6~12公里（含）4元；12~22公里（含）5元；22~32公里（含）6元
*
* @param km
* @return
*/
@Override
public int calculatePrice(int km) {
if (km <= 6) {
return 3;
} else if (km > 6 && km <= 12) {
return 4;
} else if (km > 12 && km <= 22) {
return 5;
} else if (km > 22 && km <= 32) {
return 6;
}
//其他距离简化为7元；
return 7;
}
}
我们再创建一个扮演Context角色的类。
//出行方式价格计算器
public class TrafficCalculator {
private CalculateStrategy mStrategy;
public static void main(String[] args) {
TrafficCalculator calculator = new TrafficCalculator();
//设置计算策略
calculator.setStrategy(new BusStrategy());
//计算价格
System.out.println("坐20公里的公交车票价为： " + calculator.calculatePrice(20));
}
private void setStrategy(CalculateStrategy strategy) {
this.mStrategy = strategy;
}
public int calculatePrice(int km) {
return mStrategy.calculatePrice(km);
}
}
经过重构以后，去掉了大量重复的if-else语句，结构便得清晰。另外在隐藏实现的同时，可扩展性变强。例如当我们想增加出租车为出行策略时，只需增加一个出租车计算策略类，然后将该策略设置给TrafficCalculator。如下：
//出租车价格计算策略
public class TaxiStrategy implements CalculateStrategy {
/**
* 假设每公里2元
*
* @param km 公里
* @return
*/
@Override
public int calculatePrice(int km) {
return km * 2;
}
}
将策略注入到TrafficCalculator中。
//出行方式价格计算器
public class TrafficCalculator {
private CalculateStrategy mStrategy;
public static void main(String[] args) {
TrafficCalculator calculator = new TrafficCalculator();
//设置计算策略
calculator.setStrategy(new TaxiStrategy());
//计算价格
System.out.println("坐20公里的出租车票价为： " + calculator.calculatePrice(20));
}
private void setStrategy(CalculateStrategy strategy) {
this.mStrategy = strategy;
}
public int calculatePrice(int km) {
return mStrategy.calculatePrice(km);
}
}
通过上述实例我们可以清晰地看出二者的区别所在。前者通过if-else来解决问题，虽然实现较为简单，类型层级单一，但暴露的问题非常明显，即代码臃肿，逻辑复杂，难以升级和维护，没有结构可言；后者则是通过建立抽象，将不同的策略构建成一个具体的策略实现，通过不同的策略实现算法替换。在简化逻辑、结构的同时，增强了系统的可读性、稳定性、可扩展性，这对于较为复杂的业务逻辑先得更为直观，扩展也更为方便。
总结
策略模式主要是用来分离算法，在相同的行为抽象下有不同的具体实现策略。这个模式很好的演示了开闭原则，也就是定义抽象，注入不容的实现，从而达到很好的可扩展性。
优点
- 结构清晰明了、使用简单直观；
- 耦合度相对而言较低，扩展方便；
- 操作封装也更为彻底，数据更为安全。
缺点
- 随着策略的增加，子类也会变得繁多。