策略设计模式

什么是策略设计模式？

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

为什么要用策略设计模式？

试想这样一种业务场景。公司设计了一款与鸭子有关的游戏，游戏中有各种各样的鸭子在水里嬉戏。现在游戏里一共有两种鸭子，分别是红头鸭与绿头鸭，且具备喊叫与游泳这两种行为。

每种鸭子的外观都不同，所以 display() 是抽象方法。

/**
 * 策略设计模式
 * 鸭子超类
 */
public abstract class Duck {

    public void quack() {
        System.out.println("鸭子叫");
    }

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


    public abstract void display();

}


/**
 * 绿头鸭
 */
public class MallardDuck extends Duck {

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

}


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

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

随着市场竞争变得越来越大，公司高层经过讨论决定需要给鸭子加上一个会飞的功能。这个需求太简单了，我只要一分钟就可以解决。

/**
 * 策略设计模式
 * 鸭子超类
 */
public abstract class Duck {

    public void quack() {
        System.out.println("鸭子叫");
    }

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

    public void fly() {
        System.out.println("飞翔")
    }

    public abstract void display();
}

新功能上线后的第二天，经理通知我咱们遇到了大麻烦。原来公司游戏里除了红头、绿头鸭以外还有一种橡皮鸭。现在橡皮鸭在天空中飞来飞去。这该如何是好呢？我毕竟是一个面向对象程序员，立刻就想到了使用 override 来解决这个问题。


/**
 * 橡皮鸭
 */
public class RubberDuck extends Duck {
    @Override
    public void quack() {
        //do nothing
    }

    @Override
    public void fly() {
        //do nothing
    }

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

问题解决了。可是，若是将来游戏里出现了诱饵鸭、机械鸭等等其他鸭子，每种鸭子的行为都有所不同,难道每次加入新的鸭子都去检查并覆盖duck中的方法吗？看来使用继承来为所有的鸭子提供行为会造成很多麻烦，于是我想到了尝试用接口来解决这个问题。


public abstract class Duck {

//    public void quack() {
//        System.out.println("鸭子叫");
//    }

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

//    public void fly() {
//        System.out.println("飞行");
//    }

    public abstract void display();

}

/**
 * 会飞的接口
 */
public interface Flyable {

    void fly();
}

/**
 * 会叫的接口
 *
 */
public interface Quackable {

    void quack();
}


/**
 * 绿头鸭
 */
public class MallardDuck extends Duck implements Flyable, Quackable {


    @Override
    public void fly() {
        System.out.println("飞行");
    }

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

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


/**
 * 橡皮鸭
 */
public class RubberDuck extends Duck {

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

}

将容易产生变化的行为独立抽象成为接口，在需要这些行为的子类对象中分别实现不同的具体行为，这样就避免了每个子类都需要去检查并覆盖父类方法的工作！然而，经理对这样的做法产生了疑问。由于将变化的行为声明为接口后，需要该行为的子类对象都需要去实现接口中的方法。若有100支鸭子岂不是要实现100次行为？这无疑加大了工作量甚至会造成项目延期交付！该如何是好呢？