《Headfirst设计模式》策略模式

设计原则

1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不要变化的代码放在一起
2. 针对接口编程，而不是针对实现编程
3. 多用组合，少用继承

策略模式

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

package 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 void setFlyBehavior(FlyBehavior fb){
    
    
        flyBehavior = fb;
    }
    public void setQuackBehavior(QuackBehavior qb){
    
    
        quackBehavior = qb;
    }
    public void swim(){
    
    
        System.out.println("All ducks float, even decoys!");
    }
}

package Duck;
//绿头鸭
public class MailardDuck extends Duck{
    
    
    public MailardDuck() {
    
    
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

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

package Duck;
//模型鸭
public class ModelDuck extends Duck{
    
    
    public ModelDuck() {
    
    
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }

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

我们在超类Duck中定义两个接口类，目的就是根据不同的鸭子，来调用实现接口的不同类
例如在本例中变化的部分 fly()和Quake()实现为接口，又分别实现他们的不同的行为，
这里实现了三种不同的飞行方式和三种不同的鸣叫方式
在定义不同鸭子时，继承抽象类Duck，并为 FlyBehavior flyBehavior;QuackBehavior quackBehavior;
两个接口类赋上不同的值，最后测试调用时，就会依据多态的性质调用相应的行为了

package Duck;

public interface FlyBehavior {
    
    
    public void fly();
}

package Duck;

public interface QuackBehavior {
    
    
    public void quack();
}

package Duck;

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

package Duck;

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

package Duck;

public class FlyRocketPowered implements FlyBehavior {
    
    
    @Override
    public void fly() {
    
    
        System.out.println("I'm flying with a rocket!!");
    }
}

package Duck;

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

package Duck;

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

package Duck;

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

最后就是我们的测试类和输出结果了

package Duck;

public class MiniDuckSimulator {
    
    
    public static void main(String[] args) {
    
    
        Duck mallard = new MailardDuck();
        mallard.performFly();
        mallard.performQuack();
        Duck model = new ModelDuck();
        model.performFly();
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();
    }
}

最后再回头看一下我们的策略设计模式的定义

策略模式

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