策略模式

• 策略模式

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

• UML类图

　　

• 案例: (来自Head First） 要创建一直鸭子，该鸭子有4中行为，分别是外观，叫声，飞行，游泳。

　　其中会游泳是所有的鸭子共有的行为，而飞行和叫声不同类型的鸭子各不同。

采用策略设计模式进行设计:

• 　飞行行为设计:

package strategy;

/**
 * 飞行接口
 */
public interface FlyBehavior {
    void fly();
}

package strategy;

/**
 * 不会飞
 */
public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

package strategy;

/**
 * 用翅膀飞
 */
public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("用翅膀飞行");
    }
}

• 叫声行为设计:

package strategy;

/**
 * 叫声接口
 */
public interface QuackBehavior {
    void quack();
}

package strategy;

/**
 * 呱呱叫类
 */
public class Quack implements QuackBehavior {

    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }
}

package strategy;

/**
 * 不会叫类
 */
public class MuteQuack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("不会叫");
    }
}

package strategy;

/**
 * 吱吱叫类
 */
public class Squeak implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("吱吱叫");
    }
}

• 鸭子类:

package strategy;

/**
 * 鸭子的抽象类
 */
public abstract class Duck {

    private FlyBehavior flyBehavior;
    private QuackBehavior quackBehavior;

    public Duck() {
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }

    public Duck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
        this.flyBehavior = flyBehavior;
        this.quackBehavior = quackBehavior;
    }

    public void perform() {
        display();
        swim();
        performFly();
        performQuack();
    }

    public abstract void display();

    public void swim(){
        System.out.println("会游泳");
    }

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

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

    public FlyBehavior getFlyBehavior() {
        return flyBehavior;
    }

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

    public QuackBehavior getQuackBehavior() {
        return quackBehavior;
    }

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

package strategy;

/**
 * 红头鸭类
 */
public class RedHeadDuck extends Duck {

    public RedHeadDuck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
        super(flyBehavior, quackBehavior);
    }

    @Override
    public void display() {
        System.out.println("红头鸭");
    }
}

package strategy;

/**
 * 绿头鸭类
 */
public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("绿头鸭");
    }
}

• Client调用:

package strategy;

/**
 * 该案例使用了策略模式和模板方法模式
 * 策略模式: 用在鸭子的FlyBehavior和QuackBehavior上的各种行为
 * 模板方法模式:用在Duck类中的perform()方法，该方法设定了即将执行的步骤，
 * 其中部分步骤需要子类具体实现
 *
 *   策略模式: 定义了算法族，分别封装起来，让他们之间可以互相替换，
 * 此模式让算法的变化独立于使用算法的客户。
 */
public class Client {

    public static void main(String[] args) {
        FlyBehavior flyBehavior = new FlyNoWay();
        Quack quack = new Quack();
        Duck duck = new RedHeadDuck(flyBehavior, quack);
        duck.perform();
    }
}