策略模式

策略模式：一种定义一系列算法的方法，所有的这些方法都完成相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少算法类与使用算法类间的耦合。

策略模式封装了几乎所有的类型规则，只要是在不同时间应用不同的业务规则，都可以考虑使用策略模式处理这种变化的可能性。

 

使用策略封装算法，同样+-*/的例子，来演示下先：

定义抽象策略类：

public abstract class Strategy {
	public abstract double caculate(double a,double b);
}

 

各具体算法实现类：

public class OpAdd extends Strategy {
	@Override
	public double caculate(double a, double b) {
		return a+b;
	}
}

 

策略包装类：

public class Context {
	private Strategy strategy;
	/**
	 * 典型的构造注入
	 * @param strategy
	 */
	public Context(Strategy strategy) {
		this.strategy = strategy;
	}
	public double caculate(double a,double b){
		return this.strategy.caculate(a, b);
	}
}

 

这样在调用时：

char  op =operator.charAt(0);
Context context = null;
switch (op) {
	case '+':
	       context = new Context(new OpAdd());
	       break;
	case '-':
	       context = new Context(new OpSub());
                       break;
}
double result = context.caculate(getNumber(numberA), getNumber(numberB));

 

啊哦，发现条件判断又出现在调用类中了，使用工厂方法将这些代码转移走：

在Context类中增加方法：

	public  Context(String operation) {
		char  op =operation.charAt(0);
		switch (op) {
		case '+':
			this.strategy = new OpAdd();
			break;
		case '-':
			this.strategy = new OpSub();
			break;
		}
	}

 这样的调用类就简单了：

Context context = new Context(operator);
double result = context.caculate(getNumber(numberA), getNumber(numberB));

 给出类图：

 

通过这样的封装后，来看看相互间的耦合性：

 

	调用类	Context	Strategy	具体实现类
调用类		耦合
Context			耦合	耦合
Strategy
具体实现类			继承(实现)

 

OK，调用类只要关心与Context即可。

实际应用中，Context还可以扩展，以期封装对具体算法类调用的复杂度。

 

好了，感觉Context只是组合一个Stragery这么简单吗，类的设计就这样了？

下面一张图，绝对改变了我对设计模式的思维方式：

（摘自Head First Dessign Pattern）

给我的启发：策略模式的使用主要是为了封装算法的差异性，提供算法复用，将调用的依赖止步于Context类；对于任何封装算法的类都可以称为Context，而每Strategy都是继承抽象类或实现接口的算法类。