策略模式

GitHub代码

场景阐述：通过设计一个超类鸭子而让子类继承，提取出部分公共方法进行实现，但后续添加需求时，因为设计上的问题导致无穷无尽的噩梦……

事出有因：超类鸭子负责实现公共的呱呱叫（quack）方法，后续提出需求，想要为鸭子加入fly方法以提高产品竞争力，但是由于技术失误，将此fly方法作为公共方法在超类鸭子中实现后，程序出现bug，橡皮鸭子也会飞啦！
改进策略：通过在橡皮鸭子中覆盖fly方法，实现自己的独立方法，但是这会导致每次新增一个鸭子子类时，都要考虑是否需要覆盖fly方法，并且手动再编码。

再改进：定义接口呢？提取出fly和quack，分别做成两个接口，然后由每个鸭子子类去实现；缺点显而易见，每个鸭子子类都要重写方法，异常繁琐，无穷无尽的噩梦。

设计原则：找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起。

设计原则：针对接口编程，而不是针对实现编程

“针对接口编程” 的真正意思是“针对超类型编程”。
“针对超类型编程”这句话，可以更明确地说成“变量地声明类型应该是超类型，通常是一个抽象类或者是一个接口，如此，只要是具体实现此超类型的类所产生的对象，都可以指定给这个变量。这也意味着，声明类时不用理会以后执行时的真正对象类型”。

通过上述原则，我们尝试一种新的方式来进行设计。同样是两个接口，但是由其对应类来实现具体的行为，将其和鸭子类分开。这就是可变化的部分。

我们看一下相应的代码，来更好的理解这种模式。
首先建立一个鸭子抽象类

public abstract class Duck {
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public Duck(){}

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

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

    public abstract void display();

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

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

    public void swim(){
        System.out.println("All ducks float, even decoys");
    }
}

然后为分离出来的行为新建两个接口，及其实现类

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'm flying!!");
    }
}

public interface QuackBehavior {
    public void quack();
}

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

然后根据需求新建一个鸭子子类

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");
    }
}

最后我们用一个测试类来测试一下

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

结果如下

当你将两个类结合起来使用时，就是组合。

设计原则：多用组合，少用继承。

使用组合建立系统具有很大的弹性，不仅可将算法族封装成类，更可以“在运行时动态地改变行为”，只要组合地行为对象符合正确的接口标准即可。

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

总结：该模式的核心思想是，分离出可变化的部分功能，然后通过一个算法族（也即一个接口及其的一系列实现类）来实现该功能，再将接口与原来的超类进行组合，每当需求发生变动的时候，新建子类中的接口实现类就可以根据需求进行相应的变动。从而实现了可伸缩的，弹性设计。