在开发中几女航遇见下面这种情况：实现同一个功能有很多不停的算法和策略，然后根据实际情况来选择不同的算法和策略。
一般的做法是在一个类里写不同的方法，然后根据实际情况用一连串的if-else或switch来选择对应的方法。这种方法多了后，这个类会变得臃肿，难以修改。
所以如果把不同的策略抽象出来，提供一个统一的接口，为每一个策略写一个实现类，这样客户端就能通过调用接口的不同的实现类来动态替换策略。这就是策略模式
定义
策略模式定义了一系列的算法，并将一系列算法封装起来，使他们能相互替换。策略模式让算法独立于使用者而独立变化。
使用场景
- 针对同一类型的问题有多重解决方式，仅仅是具体行为有差异时。让系统可以动态的选择算法策略。
- 需要安全的封装多重同一类对象时，调用者不会知道算法策略的具体过程。
- 一个类有多个子类，并且在调用的时候用if或switch判断的时候。
UML
简单实现
模拟一下城市交通系统，假设情况如下：
公交：起步2元，超过5公里每公里加1元。
地铁：5公里内3元，5-10公里4元，最多5元。
出租：每公里2元。
先看一下原来的写法
写一个类计算并返回价钱：
public class PriceCaculator {
public static final int BUS = 1;
public static final int SUBWAY = 2;
public static final int TAXI =3;
private int busPrice(int km){
int busP = 2;
if (km>5)
busP = busP+km-5;
return busP;
}
private int subwayPrice(int km){
int subwayP=0;
if (km<5)
subwayP = 3;
if (km>5&&km<=10)
subwayP=4;
if (km>10)
subwayP=5;
return subwayP;
}
private int taxiPrice(int km) {
return 2 * km;
}
public int getPrice(int km,int type){
if (type==BUS)
return busPrice(km);
if (type == SUBWAY)
return subwayPrice(km);
if (type==TAXI)
return taxiPrice(km);
return 0;
}
}
客户端调用，不是重点
public class Main {
public static void main(String[] args) {
PriceCaculator priceCaculator = new PriceCaculator();
int price = priceCaculator.getPrice(10,2);
System.out.println(price);
}
}
可以看到计算价钱那个类已经写了很多了，而且如果要再增加其他交通工具计算方法的话，这个类要增加相应的方法和判断。
使用策略模式
先声明一个接口，声明一个计算的方法
public interface CalculateStrategy {
int calculatePrice(int km);
}
实现三个具体的计算方法
public class BusCalculate implements CalculateStrategy {
@Override
public int calculatePrice(int km) {
int busP = 2;
if (km>5)
busP = busP+km-5;
return busP;
}
}
public class SubwayCalculate implements CalculateStrategy {
@Override
public int calculatePrice(int km) {
int subwayP=0;
if (km<5)
subwayP = 3;
if (km>5&&km<=10)
subwayP=4;
if (km>10)
subwayP=5;
return subwayP;
}
}
public class TaxiCalculate implements CalculateStrategy {
@Override
public int calculatePrice(int km) {
return 2 * km;
}
}
然后看看我们现在的计算类，这个是重点
public class PriceCalculate2 {
private CalculateStrategy calculateStrategy;
public void setCalculateStrategy(CalculateStrategy calculateStrategy){
this.calculateStrategy=calculateStrategy;
}
public int getPrice(int km){
return calculateStrategy.calculatePrice(km);
}
}
客户端调用,这个不是重点
public class Main {
public static void main(String[] args) {
PriceCalculate2 priceCalculate2 = new PriceCalculate2();
priceCalculate2.setCalculateStrategy(new SubwayCalculate());
int price = priceCalculate2.getPrice(10);
System.out.println(price);
}
}
这里重点就是计算类了，可以看到里面的解法非常简便。而且如果要新增其他算法的话，直接实现一个接口就可以了，其他类都不需要变化。便于之后的升级或扩展。
Android源码中的粗略模式
看一下一帮使用属相动画时候的样子：
Animation animation = new AlphaAnimation(1,0);
animation.setInterpolator(new AccelerateDecelerateInterpolator());
imageView.setAnimation(animation);
animation.start();
animation.setInterpolator()其实用的就是策略模式，Android中有很多不同的插值器，都实现了Interpolator接口。
然后通过setInterpolator设置给Animation。
在动画执行的时候，会通过设置的计时器来在不同的动画时间执行不同的动画效果。
public void setInterpolator(Interpolator i) {
mInterpolator = i;
}
protected void ensureInterpolator() {
if (mInterpolator == null) {
//默认就是加速度插值器,在Animation初始化的时候执行。
mInterpolator = new AccelerateDecelerateInterpolator();
}
}
public boolean getTransformation(long currentTime, Transformation outTransformation) {
......
if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
......
//通过策略模式来获取不同的值。
final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
applyTransformation(interpolatedTime, outTransformation);
}
......
}
总结
策略模式主要就是为了分离算法和使用，是系统用于很好的拓展性
优点
- 结构清晰明了，消除了代码中的一大串选择语句，而是分离为一个个独立的类，代码更清晰。
- 耦合度低，都是基于接口调用和实现，便于拓展和修改。
- 封装更彻底，数据更安全。
缺点
- 首先是会产生很多策略类，增加了系统开销。
- 用户要知道所有的策略类。