定义： The Strategy Pattern defines a family of algorithms,encapsulates each one,and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.（策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。）
怎么理解策略模式的定义呢？先大概整理说明一下这个来自head first中Duck的例子。
场景条件：鸭子都有swim、quack、fly行为，这里假定所有的鸭子都会游泳。
问题：现在要实现各种不同的鸭子（子类），不同的鸭子有不同的display。
解决方案：
1、将Duck设置为抽象类，实现swim、quack、fly方法，抽象display方法。所有的子类都继承自Duck，实现display。
存在的问题：有的鸭子会叫，有的不会叫。同样的，有的会飞，有的不会飞。所以在抽象类里面实现quack和fly方法不可行。
2、将quack和fly方法抽离出来，分别作为两个接口的方法，根据鸭子会不会飞、会不会叫独立的实现一个接口或者两个接口。
存在问题：如果有很多的子类，那么每个子类都需要实现这两个接口，并且有很多子类所表现出来的quack和fly行为一样，这么一来很有可能将quack和fly重复实现了很多次，这是一种冗余，而且也是无谓的工作。
3、策略模式：接口将系统的不同部分隔离开来（方法的具体实现隔离开），同时又将它们连接在一起（接口的行为放在一起，不同的行为相当于系统的不同部分。）
先看一个具体的例子：
定义两个接口，将quack和fly方法抽离出来。
public interface FlyBehavior {
public Object Fly();//将具体实现抽离出来
}
public interface QuackBehavior {
public Object Quack();
}
定义几个类，实现这两个接口。
public class FlyNoWay implements FlyBehavior {
@Override
public Object Fly() { //定义具体的实现
return "不会飞";
}
}
public class FlyWithWings implements FlyBehavior {
@Override
public Object Fly() { //有多少方式就有多少实现
return "我飞啦！";
}
}
public class Quack1 implements QuackBehavior {
@Override
public Object Quack() {
return "嘎嘎";
}
}
public class Quack1 implements QuackBehavior {
@Override
public Object Quack() {
return "吱吱";
}
}
实现子类继承Duck
public class RedHeadDuck extends Duck {
public RedHeadDuck(){
super.setFlyBehavior(new FlyWithWings());//根据不同的需求把实现set到相应的步骤当中。
super.setQuackBehavior(new Quack1());
}
@Override
public Object display() {
return "我是一只红头鸭";
}
}
public class RubberDuck extends Duck {
public RubberDuck() {
super.setFlyBehavior(new FlyNoWay());
super.setQuackBehavior(new Quack2());
}
@Override
public Object display() {
return "我是一只橡皮鸭";
}
}
运行以及运行结果：
public class Strategy {
public static void main(String[] args) {
RedHeadDuck redHeadDuck = new RedHeadDuck();
RubberDuck rubberDuck = new RubberDuck();
System.out.println(redHeadDuck.display()+","+redHeadDuck.fly()+","+redHeadDuck.quack()); //相同的方法，但由于set了不同的实现，所以表现出了不同的结果
System.out.println(rubberDuck.display()+","+rubberDuck.fly()+","+rubberDuck.quack());
}
}
我是一只红头鸭,我飞啦！,嘎嘎
我是一只橡皮鸭,不会飞,吱吱
这里打个比方，对于一件事情，有相同的步骤。不同的人去做，可能步骤的顺序不一样，每一步的具体实现方法也不一样。我们需要的就是把步骤的具体实现抽离出来，有多少不同的实现，就具体定义多少不同的实现。对于不同的人，只需要对于不同的步骤，选择自己的实现方法就行。
上例中fly、quack方法相当于“步骤”，FlyNoWay和FlyWithWings相当于步骤的具体实现。根据不同的需要，把实现set到相应的步骤当中。
这时返回到策略的定义，“算法”在这里指的就是FlyBehavior和QuackBehavior的不同实现。
策略模式的优点不多说，但是缺点也是显而易见的。 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。