《每天学一个设计模式》 之 策略模式

策略模式(Strategy Pattern, also known as Policy Pattern)，是一种比较简单的行为型设计模式(Behavioral Design Pattern)，它的核心思想是：多个策略（Strategy1, Strategy2, …）实现同一个接口（IStrategy），由一个Context类来封装对策略的访问。

策略模式的完整定义是：
（1）defines a family of algorithms (定义一个算法集合);
（2）encapsulates each algorithm (封装每一个算法);
（3）makes the algorithms interchangeable within that family (使得算法集合里的算法可以相互替换).

看一个具体的例子 (Java 语言实现)：

// 1. 一组汽车集合，所有汽车都实现了ICar接口
public interface ICar {
    public void engineStart();
}

public class Porsche implements ICar {
    @Override
    public void engineStart() {
        System.out.println("Porsche: engine start...");
    }
}

public class Audi implements ICar {
    @Override
    public void engineStart() {
        System.out.println("Audi: engine start...");
    }
}

// 2. 一个封装了所有汽车的中间类
public class Context {
    private ICar car;
    public Context(ICar car) {
        this.car = car;
    }

    public void prepareToRun() {
        car.engineStart();
    }
}

// 3. 具体场景类
public class Client {
    public static final String PORSCHE = "porsche";
    public static final String AUDI = "audi";

    public static void main(String[] args) {
        String carType = args[0];
        Context context = null;
        if (PORSCHE.equals(carType)) {
            context = new Context(new Porsche());
        } else {
            context = new Context(new Audi());
        }
        context.prepareToRun();
    }
}

通过这个具体的例子我们可以看出：我们使用了一个Context准备了一组算法([Porsche, Audi]), 并封装了起来，具体使用哪一个策略由上层的模块Client来决定。可以看出，策略模式主要依赖面向对象的继承和多态机制。

策略模式的优点： （1）算法可以自由切换。

由模式的本身定义可知，只要实现了抽象的策略，通过封装角色的封装，就可以对外提供可以自由切换的策略。

（2）良好的扩展性。

添加新的策略非常简单，只要实现抽象策略就行，非常符合开闭原则(Open-Closed Principle)。

（3） 避免使用多重判断。

当然，通过之前的例子我们可以看出，策略模式也有明显的缺点： （1）策略类之间不可复用，每新增一个策略都需要定义新的类。 （2）所有的策略类都需要对外暴露。

上层模块必须知道所有的策略，才能决定使用哪一个策略。

Last but not the least, 让我们看看策略模式适合应用于哪些场景：
1. 多个类只在算法实现上不同。
2. 有多个算法可以相互替换，在未来还可能有新的算法加入。
3. 屏蔽算法的实现细节，用户只需要记住算法的名称，即可完成对算法的使用。
4. 未完待续…

参考资料:
1.《设计模式之禅》，秦小波，机械工业出版社，2010.1
2. https://en.wikipedia.org/wiki/Strategy_pattern