策略模式（Strategy）

定义

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

适用范围

• 许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为来配置一个类的方法。
• 需要使用一个算法的不同变体。例如，定义一些反应不同的时间/空间权衡的算法。
• 算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。
• 一个类定义了多种行为，并且这些行为在这个类的操作中心以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以替代这些条件语句。

框架

实例

单看上面的纯理论的东西，很是头晕，有种虚无缥缈之感，现在来用一个具体的例子来说明什么是策略模式。

假设要设计一个鸭子的游戏，鸭子的主要行为就是叫（quack）和飞（fly），游泳（swim）。当然，不同种类的鸭子的叫声是不同的，甚至有些鸭子是不会叫的，比如说一只玩具鸭子，同理，有些鸭子是不会飞的，不过我们认为鸭子游泳是一样的行为。那么我们如何设计出一个有弹性的代码呢？

public abstract class Duck {
    public void quack();
    public void fly();
    public void swim();
    abstract void display();
}

因为每一种鸭子的外观是不同的，所以display()方法是抽象的。那么对于不同类的鸭子我们只要继承上面的这个Duck超类，然后我们重写quack()和fly()方法就好了。这种想法是很直接的，也是最容易想到的，但是这样做的代价是非常巨大的，因为需求的一丁点更改，都需要使得程序员修改大量的代码，扩展性非常的糟糕，重写方法的工作量也非常琐碎繁重。有更好一些的idea吗？

设计原则中有一条就是，找出应用中可能需要变化之处，然后把它们独立出来，不要和那些不需要变化的代码混在一起。基于这条原则，理所当然的把Duck类中变化的部分，即fly和quack单独拿出来。创建两个单独的接口Flyable和Quackable，将fly和quack方法分别放入这两个接口。那么现在每一种不同类型的鸭子就可以继承删减后的Duck类并且实现Flyable和Quackable中这两个接口。貌似问题得到了解决。但是，这样设计有一个致命的弊端，就是比前面的那中直接继承的方法相比，重复的代码变的更多，前面只是override几个方法。所以此法也是不可取的。
其实这种方法已经非常慢慢向优雅的方向靠近了，就快要接近真理了。

现在我们来看看最终解决鸭子问题的方法——策略模式。从Duck中抽离出来变化的部分fly和quack是没有错的，把它们作为接口也是没有问题的（把这两个接口命名为FlyBehavior和QuackBehavior）。如下所示：

public interface QuackBehavior {
    public void quack();
}

public interface FlyBehavior {
    public void fly();
}

关键在于对于quack和fly的具体实现不要实现在Duck的派生类中，而是将不同的quack和fly单独用类实现其接口，它们就是策略模式中的算法族，只不过这里出现了2个算法族而已。如下所示，有实现了3种quack和3种fly。

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

public class MuteQuack implements QuackBehavior {
    public void quack() {
        System.out.println("Silence!");
    }
}

public class Squack implements QuackBehavior {
    public void quack() {
        System.out.println("Squack!");
    }
}

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

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

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

此时我们所关注的Duck类如下：

public abstract class Duck {
    QuackBehavior quackBehavior;
    FlyBehavior flyBehavior;

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

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

    public void setQuackBehavior(QuackBehavior qb) {
        quackBehavior = qb;
    }

    public void setFlyBehavior(FlyBehavior fb) {
        flyBehavior = fb;
    }

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

    abstract void display();
}

很明显可以看出，Duck类中已经将quack和fly的动作委托（delegate）给别人处理了，而不是自己处理。“多用组合，少用继承”，这个例子也很好的印证了这条设计原则。下面实现两种具体的鸭子，即MallardDuck和ModelDuck。

public class MallardDuck extends Duck {
    public MallardDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    public void display() {
        System.out.println("I'm a real mallard duck");
    }
}

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

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

写出主函数，看看测试结果

public class MiniDuckSimulator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Duck mallard = new MallardDuck();
        mallard.performQuack();
        mallard.performFly();

        Duck model = new ModelDuck();
        model.performFly();
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();
    }
}

参考文献：

1. 《Head First 设计模式》
2. 《设计模式——可复用面向对象软件的基础》
3. http://en.wikipedia.org/wiki/Strategy_pattern