定义：定义一组算法，将每个算法都封装其阿里，并且使它们之间可以互换。

策略模式的一般模式:

Context封装角色
---|它也叫作上下文对象，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，
封装可能存在的变化。
Strategy抽象策略角色
---|策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。
ConcreteStrategy具体策略角色

---|实现抽象策略中的操作，该类含有具体的算法。

public class StrategyT {
	public static void main(String[] args) {
		//实现某个算法。
		Context context = new Context(new ConcreteStrategy());
		context.action();
	}
}
interface Strategy{
	//实现具体的算法操作
	public void doSomething();
}
class ConcreteStrategy implements Strategy{
	@Override
	public void doSomething() {
	System.out.println("come on operate some Arithmetics...");
	}
}
class Context{
	//私有方法指向具体的策略实现者
	private Strategy strategy;
	
	public Context(Strategy strategy) {
		this.strategy = strategy;
	}
	public void action(){
		this.strategy.doSomething();
	}
}

一个例子:

诸葛亮锦囊妙计的故事大家都听说过，那么在这个故事中也涉及到一个设计模式的道理。
首先，诸葛亮给赵云三个锦囊，锦囊中分别是三个妙计，赵云在固定的地点打开锦囊，执行其任务，
便能够化险为夷。那么我们用代码去实现这个策略模式吧。

public class StrategyTest {
	public static void main(String[] args) {
		//赵云来到吴国，打开第一个锦囊
		System.out.println("-------赵云来到吴国，打开第一个锦囊-----------");
		MyContext context1 = new MyContext(new BackDoor()); 
		//执行第一个锦囊妙招
		context1.operate();
		System.out.println("-------遇到麻烦打开第二个锦囊-------------");
		//遇到麻烦打开第二个锦囊
		MyContext context2 = new MyContext(new BackDoor()); 
		//执行第一个锦囊妙招
		context2.operate();
		System.out.println("-------想要溜走，又遇到麻烦---------");
		//想要溜走，又遇到麻烦
		MyContext context3 = new MyContext(new BackDoor()); 
		//执行第一个锦囊妙招
		context3.operate();
	}
}
interface IStrategy{
	//锦囊中的妙计，实现方法.具体的实现算法
	void operate();
}
/**
 * 锦囊妙计一
 * @author admin
 *
 */
class BackDoor implements IStrategy{
	@Override
	public void operate() {
		System.out.println("找乔国老开后门");
	}
}
/**
 * 锦囊妙计二
 * @author admin
 *
 */
class GivenGreenLight implements IStrategy{
	@Override
	public void operate() {
		System.out.println("找吴国太开绿灯");
	}
}
/**
 * 锦囊妙计三
 * @author admin
 *
 */
class BlockEnemy implements IStrategy{
	@Override
	public void operate() {
		System.out.println("孙夫人断后");
	}
}
/**
 * 具体的承载妙计的锦囊。
 * @author admin
 *
 */
class MyContext {
	//一个私有对象指向具体的实现算法类。
	private IStrategy strategy;
	
	public MyContext(IStrategy strategy) {
		this.strategy = strategy;
	}
	public void operate(){
		this.strategy.operate();
	}
}

策略模式的优点：
---|算法可以自由切换
---|避免使用多重条件的判断
---|扩展性良好

策略模式的缺点
---|策略类数量增多
---|所有的策略类需要对外暴露

策略模式的使用场景
---|多个类只有在算法或行为上稍有不同的场景
---|算法需要自由切换的场景
---|需要屏蔽算法规则的场景