策略模式

（《设计模式解析与实战》读书笔记）

一、定义
策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们之间可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
二、使用场景
(1)针对同一类型问题的多种处理方式，仅仅是具体行为有差别时；
(2)需要安全的封装多种同一类型的操作时；
(3)出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时。
三、简单示例
解决一个问题可以有多种方法（算法）。

/**
 * 解决问题的抽象接口
 */
public interface Solve {

    /**
     * 抽象算法
     */
    void method();
}

/**
 * 算法A
 */
public class MethodA implements Solve {

    /**
     * 算法A
     */
    @Override
    public void method() {
        System.out.println("我是算法A");
    }
}

/**
 * 算法B
 */
public class MethodB implements Solve {

    /**
     * 算法B
     */
    @Override
    public void method() {
        System.out.println("我是算法B");
    }
}

/**
 * 算法策略
 */
public class CalculativeStrategy {
    public static void main(String[] args) {

        CalculativeStrategy strategy = new CalculativeStrategy();
        // 设置算法策略
        strategy.setStrategy(new MethodA());
        // 计算结果
        System.out.println("选择A算法计算的结果：" + strategy.caclulate());

        // 设置算法策略
        strategy.setStrategy(new MethodB());
        // 计算结果
        System.out.println("选择B算法计算的结果：" + strategy.caclulate());
    }

    Solve mSolve;

    /**
     * 设置算法策略
     * 
     * @param solve
     *            具体算法
     */
    public void setStrategy(Solve solve) {
        this.mSolve = solve;
    }

    /**
     * 计算相应算法
     * 
     * @return 计算结果
     */
    public String caclulate() {
        return "我是计算结果";
    }
}

这种模式去掉了各种各样的if-else语句，可扩展性也变得很强。
比如，再增加算法C：

/**
 * 算法C
 */
public class MethodC implements Solve {

    /**
     * 算法C
     */
    @Override
    public void method() {
        System.out.println("我是算法C");
    }
}

然后将该算法策略注入到给CalculativeStrategy。

        // 设置算法策略
        strategy.setStrategy(new MethodC());
        // 计算结果
        System.out.println("选择C算法计算的结果：" + strategy.caclulate());

运行结果：

四、优缺点
优点：
(1)结构清晰明了，使用简单直观；
(2)耦合度相对而言较低，扩展方便；
(3)操作封装也更为彻底，数据更为安全。
缺点：
随着策略的增加，子类也会变得繁多。