策略模式

策略模式：定义了算法家族，分别封装起来，让他们时间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。

策略模式的结构如如下：

 

 抽象算法类实现：

package com.kunl.strategy;

/**
 * @author fokman
 * @version 1.0
 * @created 29-五月-2011 22:18:45
 */
public abstract class Strategy {

	public Strategy(){

	}

	public void finalize() throws Throwable {

	}

	public abstract void algorithmInterface();

}

 

具体算法类A：

package com.kunl.strategy;

/**
 * @author fokman
 * @version 1.0
 * @created 29-五月-2011 22:18:45
 */
public class ConcreteStrategyA extends Strategy {

	public void finalize() throws Throwable {
		super.finalize();
	}

	public void algorithmInterface(){
		System.out.println("算法A实现");
	}

}

 

具体算法类B：

package com.kunl.strategy;

/**
 * @author fokman
 * @version 1.0
 * @created 29-五月-2011 22:18:45
 */
public class ConcreteStrategyB extends Strategy {


	public void finalize() throws Throwable {
		super.finalize();
	}

	public void algorithmInterface(){
		System.out.println("算法B实现");
	}

}

 

具体算法类C：

package com.kunl.strategy;

/**
 * @author fokman
 * @version 1.0
 * @created 29-五月-2011 22:18:45
 */
public class ConcreteStrategyC extends Strategy {

	public void finalize() throws Throwable {
		super.finalize();
	}

	public void algorithmInterface(){
		System.out.println("算法C实现");
	}

}

 

Context类，用来维护对Strategy对象的引用：

package com.kunl.strategy;

/**
 * @author fokman
 * @version 1.0
 * @created 29-五月-2011 22:18:45
 */
public class Context {

	public Strategy strategy;

	public Context(Strategy strategy){
		this.strategy = strategy;
	}

	public void contextInterface(){
		strategy.algorithmInterface();
	}

}

 

客户端调用：

package com.kunl.strategy;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Context context;
		context = new Context(new ConcreteStrategyA());
		context.contextInterface();
		
		context = new Context(new ConcreteStrategyB());
		context.contextInterface();
		
		context = new Context(new ConcreteStrategyC());
		context.contextInterface();
	}

}

 总结：

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

当不通的行为堆积在一个类的时候，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。