策略模式

策略模式：
定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式让算法的变化可以独立于算法的客户。

具体实例：
现在我们要创建各种鸭子对象，这些鸭子有者不同的行为能力，会叫的，会飞的，不会叫的，不会飞的，飞得很快像火箭一样的等等。

我们首先分析鸭子的能力主要有两种，叫与飞。因此我们将这两种能力剥离出来，定义为了接口。叫的差异化在叫的具体行为类来实现。飞的差异化能力在飞的具体类实现。

这样我们就将接口与实现分离了。

行为接口就像是一类算法，具体的行为类就是这类算法的差异化实现。当要扩展这类算法时，只需要添加新的行为类。

代码样例：

飞动作的行为接口
public interface FlyBehavior {
    public void fly();
}

叫动作的行为接口
public interface QuackBehavior {
    public void quack();
}

飞的具体行为类1
public class FlyNoWay implements  FlyBehavior{
    @Override
    public void fly() {
        System.out.println("i cant not fly");
    }
}

飞的具体行为类2
public class FlyWithWings implements  FlyBehavior{
    @Override
    public void fly() {
        System.out.println("i am flying");
    }
}

飞的具体行为类3
public class FlyWithRocket implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("i am flying with rocket");
    }
}

叫的具体行为类1
public class MuteQuack implements QuackBehavior{
    @Override
    public void quack() {
        System.out.println("silence");
    }
}

叫的具体行为类2
public class Quack implements  QuackBehavior{
    @Override
    public void quack() {
        System.out.println("quack: gua gua gua");
    }
}

抽象类Duck是具有叫和飞行为的一类对象，我们将Duck定义为了抽象类，在该类中包含了行为接口，通过行为接口对具体行为类的引用（多态），达到了行为的多态实现。

public abstract class Duck {
    //行为接口
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;
    public void performFly(){
        flyBehavior.fly();
    }
    public void performQuack(){
        quackBehavior.quack();
    }
    //赋予飞这个具体动作类的引用
    public void setterFlyBehavior(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }
     //赋予叫这个具体动作类的引用
    public void setterQuackBehavior(QuackBehavior quackBehavior){
        this.quackBehavior = quackBehavior;
    }
    public abstract void display();
}

鸭子对象：
通过构造函数填充鸭子的行为
public class ModelDuck extends Duck{
    //在鸭子的构造器内实例化鸭子的行为
    public ModelDuck(){
        this.flyBehavior = new FlyNoWay();
        this.quackBehavior = new MuteQuack();
    }

    @Override
    public void display() {
        System.out.println("i am a model duck");
    }
}


通过set方法赋予鸭子的行为。
public class NewModelDuck extends Duck{
    @Override
    public void display() {
        System.out.println("i am a new duck");
    }
}

测试：
public class DuckSimulator {
    public void duckConstructBehavior() {
        Duck model = new ModelDuck();
        model.performFly();
        model.performQuack();
    }

    public void duckSetterBehavior(){
        Duck newModelDuck = new NewModelDuck();
        newModelDuck.setterFlyBehavior(new FlyWithRocket());
        newModelDuck.setterQuackBehavior(new Quack());
        newModelDuck.performQuack();
        newModelDuck.performFly();
    }
}

import junit.framework.TestCase;

public class DuckSimulatorTest extends TestCase {
    private
    DuckSimulator duckSimulator = new DuckSimulator();

    public void testDuckConstructBehavior() {
        duckSimulator.duckConstructBehavior();
    }

    public void testDuckSetterBehavior() {
        duckSimulator.duckSetterBehavior();
    }
}

测试结果：

i am a model duck
i cant not fly
silence
i am a new duck
quack: gua gua gua
i am flying with rocket