设计模式：策略模式

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

　　说白了就是将客户和算法分离开来，下面客户就是Duck的具体类，算法就是封装好的飞行行为，呱呱叫行为。让我们直接看代码吧。

　　首先创建客户类Duck代码，具体实现类实现抽象类Duck

public abstract class Duck {
    //声明飞行行为、呱呱叫行为的引用变量
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;
    
    public Duck(){
        
    }
    
    public abstract void display();
    
    public void performFly(){
        //委托给行为类
        flyBehavior.fly();
    }
    public void performQuack(){
        quackBehavior.quack();
    }
}

public class MullardDuck extends Duck{
    
    public MullardDuck(){
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }
    
    @Override
    public void display() {
        System.out.println("I am a real Mallard Duck ");
    }
}

　　　接着实现算法，即行为类，其中飞行实现类实现抽象类FlyBehavior，呱呱叫也一样

public interface FlyBehavior {
    public void fly();
}

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

public class FlyWithWings implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I am flying!");
    }
}

public interface QuackBehavior {
    public void quack();
}

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

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

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

　　最后我们进行测试

public class Test {
    public static void main(String[] args) {
        Duck mallard = new MullardDuck();
        mallard.performQuack();
        mallard.performFly();
    }
}

　　运行结果如下：

　　

　　好了，这就是策略模式了，把客户和算法分离即可。

　　下一节：观察者模式