作者在看HeadFirst设计模式，把整个学习过程记录下来，方便以后回顾，也可以与大家交流，欢迎拍板。整个系列每篇文章围绕why,how,conclusion这三方面展开。
1. 为什么需要策略模式
考虑到如下一个场景，你构造一个Duck的SuperClass,以后各种各样的鸭子都继承该SuperClass ,代码实现应该如下。
public class Duck {
public void quack(){ //会叫
System.out.println("I can quack");
}
public void swim(){ //会游泳
System.out.println("I can swim");
}
public void play(){ //外表
System.out.println("I am a special duck with good look");
}
}
具体的实现类如下
public class GreeHeadDuck extends Duck { //绿头鸭
@Override
public void play(){
System.out.println("I am green duck");
}
}
public class RedHeadDuck extends Duck{ //红头鸭
@Override
public void play(){
System.out.println("I am red duck");
}
}
上面这样看起来也没毛病啊，但是它有个问题就是，当给SuperClass加上fly()方法后，表示每个子类都会飞。即便是我后来的子类不能飞，它也可以fly。此时，我们可能会想到，覆盖fly()方法，方法里面什么都不做。但是问题还是很突出。原因如下：
- 代码在多个子类中重复。不管是什么类型的鸭子，都会继承来SuperClass的所有属性和方法，这其中有些子类根本就不具备。
- 运行时的行为不容易改变。我想让某个鸭子换个叫声，在不动SuperClass的情况下做不到。
- 很难知道所有鸭子共同的行为。比如fly方法，有些鸭子不具备，但是还是在父类中。
- 改一发动全身，我上面还是只添加fly(),有些鸭子不会飞，但是要覆盖方法。
我们接着可能会采用如下的解决办法，把fly,display从超类中抽出来，放进一个Flayable接口中。把quack()抽出来，放进Quackable接口中，代码如下。
public interface Quackable { //会叫的接口
public void quack();
}
public interface Flyable { //会飞接口
public void fly();
}
这样对于多个会飞Duck子类，每个子类都有一个实现Flyable()的类，在里面覆写fly()方法，会造成太多Flyable()的子类，无法复用。其次，还不能动态改变fly行为，因为已经写死啦。此时，设计原则就出来了，即：找出应用之中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混到一起。
2. 如何使用策略模式
解决上述问题的根本是分开变化和不会变化的部分。Duck类中的fly(),quack()会随着鸭子的不同而改变，那我们将它们从Duck类中取出来，建立一组新类来代表每个行为。此时，设计原则就应用上了即，针对接口编程，而不是针对实现编程 这句话的理解在这里就是针对超类编程。前面我们设计 Quackable，Flyable，然后让具体的类去实现这两个接口，这样，就是针对实现编程，不利于动态修改和以后的拓展。因此，我们编写两个FlyBehavior,QuackBehavior两个接口，以及他们的实现类，这样，我们把FlyBehavior和QuackBehavior作为超类的属性，这个具体的实现通过set方法通过set()传递进去，这样实现面向接口编程，可以动态改变，也可以复用代码。代码实现如下：
行为接口
public interface FlyBehavior {
public void fly();
}
public interface QuackBehavior {
public void quack();
}
实现类
public class FlyNoWay implements FlyBehavior { //不能飞
@Override
public void fly() {
System.out.println("I can FlyNoWay");
}
}
public class FlyWithWins implements FlyBehavior { //用翅膀飞
@Override
public void fly() {
System.out.println("i can fly with wins");
}
}
public class Quack implements QuackBehavior { //一般的叫
@Override
public void quack() {
System.out.println("quack");
}
}
public class Squack implements QuackBehavior { //嘶叫
@Override
public void quack() {
System.out.println("squack");
}
}
把基本接口作为超类的属性成员，面向接口编程
public class Duck {
private FlyBehavior flyBehavior; //代理类，组合模式
private QuackBehavior quackBehavior;
public void fly(){
flyBehavior.fly();
}
public void quack(){
quackBehavior.quack();
}
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
public void swim(){ //会游泳
System.out.println("I can swim");
}
public void play(){ //外表
System.out.println("I am a special duck with good look");
}
}
测试类如下
public class Main {
public static void main(String[] args) {
Duck duck=new Duck();
duck.setFlyBehavior(new FlyNoWay());
duck.fly();
duck.setFlyBehavior(new FlyWithWins());
duck.fly();
}
}
结果如下图
总结：上述做法的好处，面对不同飞行类型，可以在不修改Duck的基础上实现，这就是策略模式，根据你传入进来的具体实现类，执行不同的行为，这里关键就是运用多态这一特点。其次，不同的实现类可以复用，以前针对每个子类都有实现类，现在同一类型的都可以采用同一个实现类。
3. 结论
策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户，简单来说，就是定义了基础接口封装在类属性里面，可以根据不同的实现类，动态的改变行为。
