策略模式（StrategyPattern）

策略模式

定义了算法族，分别封装起来，让它们之间可以互相替换，让算法的变化独立与使用算法的对象；

---

在OOP时经常性使用得语言特性无外乎是抽象、继承、多态，这些特性可以帮助我们在编程时减少重复性代码，对原有类可以不断重用，让我们的思维模式与现实世界无缝接合；
可是这些特性的使用，却不一定带来好处也有可能带来不可预知的噩梦！

---

一个抽象类Duck拥有quack（）、swim（）、display（）等方法，子类通过继承来复用父类的方法以实现各自功能；然而当父类发生变化时如增加fly（）方法，由于继承使父类的变化所带来得影响具有延展性；这种影响对于整套系统而言，尤其整套系统非常庞大时产生的结果具有不可预知性；（这可是很可怕的）
而一个接口Duck拥有quack（）、swim（）、display（）等方法，具体类通过实现以实现自身功能且保持一致性；而接口一旦发生了变化所有实现类都会受到牵连，其带来的体力性劳动实在让人烦躁了；

• 抽象类+继承（abstract+extends），父类改变，却导致全局性功能变化；
• 接口类+实现（interface+implements），接口类的改变，却带来的重复性体力活动；

---

针对上述想法，当我们在设计时需要找出应用中可能需要变化之处，把它们独立出来，与不变相互分离；同时，我们应该针对接口编程，而不是针对实现编程；（此处接口编程指得利用多态，程序可以针对超类型，在执行时根据实际情况执行到真正的行为）：

---

举个栗子：

将一组不断变化的行为类专门独立实现FlyBehavior与QuackBehavior：
FlyBehavior

public interface FlyBehavior {
    public void fly();
}

QuackBehavior

public interface QuackBehavior {
    public void quack();
}

对应变化具体行为类FlyWithWings和FlyNoWay、Squeak和MuteQuack:
FlyWithWings

public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("Flying with wings.");
    }
}

FlyNoWay

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("I can't fly!");
    }
}

Squeak

public class Squeak implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("Squeak.");
    }
}

MuteQuack

public class MuteQuack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("<<Slience>>.");
    }
}

主体抽象类：
Duck

public abstract class Duck {
    FlyBehavior flyBehavior;//封装变化行为,采用接口
    QuackBehavior quackBehavior;//封装变化行为,采用接口

    public void performFly()
    {
        flyBehavior.fly();
    }

    public void performQuack()
    {
        quackBehavior.quack();
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }

    public abstract void display();

    public void swim()
    {
        System.out.println("swimming!");
    }
}

具体实现类：
MallardDuck

public class MallardDuck extends Duck {

    public MallardDuck()
    {
        flyBehavior = new FlyWithWings();//由实现类指定具体实现行为
        quackBehavior = new Quack();//由实现类指定具体实现行为
    }

    @Override
    public void display() {
        System.out.println("I'm a real Mallard duck!");
    }

}

采用接口+抽象组合起来进行实现，对于可变部分行为我们可以在运行的过程中进行改变，对于固定部分行为我们可以在抽象主类中进行添加，即可以减少重复代码、又可以动态改变；

参考资料：Head First设计模式