java设计模式--策略模式

策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

本文地址：http://www.cnblogs.com/wuyudong/p/5924223.html，转载请注明源地址。

策略模式的结构

　　策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。下面就以一个示意性的实现讲解策略模式实例的结构。



这个模式涉及到三个角色：

　　●　环境(Context)角色：持有一个Strategy的引用。

　　●　抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

　　●　具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

策略模式的使用场景：

1）针对同一种问题的多种处理方式、仅仅是因为具体行为有差别时，

2）需要安全的封装多种同一类型的操作时

3）出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时。

策略模式的实现

举个例子，计算公交车和地铁运行指定路程后所需的票价

package com.wuyudong.strategy.normal;

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("坐10公里的公交车的票价为："
+ calculator.calculatePrice(10, BUS));
System.out.println("坐10公里的地铁的票价为："
+ calculator.calculatePrice(10, SUBWAY));

}

//计算公交价格
private int busPrice(int km) {
int extraTotal = km - 10;
int extraFactor = extraTotal / 5;
int fraction = extraTotal % 5;
int price = 1 + extraFactor * 1;
return fraction > 0 ? ++price : price;
}

//计算地铁价格
private int subwayPrice(int km) {
if (km <= 6) {
return 3;
} else if (km > 6 && km < 12) {
return 4;
} else if (km < 22 && km > 12) {
return 5;
} else if (km < 32 && km > 22) {
return 6;
}
return 7;
}

//根据类型来计算相应的价格
private int calculatePrice(int km, int type) {
if (type == BUS) {
return busPrice(km);
} else {
return subwayPrice(km);
}
}
}

如果再添加一种出租车的价格计算，添加相应的代码：

public class PriceCalculator {
// 公交车类型
private static final int BUS = 1;
// 地铁类型
private static final int SUBWAY = 2;

// 出租车类型
private static final int TAXI = 3;

public static void main(String[] args) {
PriceCalculator calculator = new PriceCalculator();
System.out.println("坐10公里的公交车的票价为："
+ calculator.calculatePrice(10, BUS));
System.out.println("坐10公里的地铁的票价为："
+ calculator.calculatePrice(10, SUBWAY));

}

// 计算出租车价格
private int taxiprice(int km) {
return km * 2;
}

// 根据类型来计算相应的价格
private int calculatePrice(int km, int type) {
if (type == BUS) {
return busPrice(km);
} else if (type == SUBWAY) {
return subwayPrice(km);
} else {
return taxiprice(km);
}
}
}

可见上面的代码耦合性较高，每当增加新的交通工具类型的时候，需要不断的修改大量的代码，这里使用策略模式重构：

首先定义一个抽象的价格计算接口：

//计算接口
public interface CalculateStrategy {
int calculatePrice(int km);
}

每一种出行方式都定义一个独立的计算策略类：

公交车计算策略

public class BusStrategy implements CalculateStrategy {
public int calculatePrice(int km) {
int extraTotal = km - 10;
int extraFactor = extraTotal / 5;
int fraction = extraTotal % 5;
int price = 1 + extraFactor * 1;
return fraction > 0 ? ++price : price;
}

}

地铁计算策略

public class SubwayStrategy implements CalculateStrategy {

public int calculatePrice(int km) {
if (km <= 6) {
return 3;
} else if (km > 6 && km < 12) {
return 4;
} else if (km < 22 && km > 12) {
return 5;
} else if (km < 32 && km > 22) {
return 6;
}
return 7;
}
}

再创建一个扮演Context的角色，代码如下：

public class TranficCalculator {
CalculateStrategy mStrategy;

public static void main(String[] args) {
TranficCalculator calculator = new TranficCalculator();
//设置计算策略
calculator.setStrategy(new BusStrategy());
//计算价格
System.out.println("公交车乘10公里的价格：" + calculator.calculatePrice(10));

}

public void setStrategy(CalculateStrategy mStrategy) {
this.mStrategy = mStrategy;
}
public int calculatePrice(int km) {
return mStrategy.calculatePrice(km);
}
}

这样即使需要添加出租车的价格计算，只需要简单的新建一个类，让其继承自CalculateStrategy接口并实现其中的方法即可

优点

1）结构清晰明了、使用简单直观

2）耦合度相对较低，扩展方便

3）操作封装因为更为测地、数据更为安全

缺点

子类增多