设计模式学习与整理-策略模式

        在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

使用场景： 

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 
2、一个系统需要动态地在几种算法中选择一种。 
3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

        

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

 

模式结构：

        Strategy：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
        ConcreteStrategy：包装了相关的算法或行为。

        Context：持有一个Strategy的引用。

代码案例：

        简单的计算器：计算器有三种类似的算法（加法 减法 乘法），因为这三种方法类似，所以使用策略模式实现一下

策略接口：

public interface Strategy {

    public int doOperation(int num1, int num2);

}

三个策略实现类：

/**加*/
class OperationAdd implements Strategy{
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}
/**减*/
class OperationSubstract implements Strategy{
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}
/**乘*/
class OperationMultiply implements Strategy{
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}

上下文类：

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy){
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2){
        return strategy.doOperation(num1, num2);
    }
}

main方法类：

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationSubstract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

结果输出：

    简单的计算器就出来了，但是有一点不足，就是程序需要知道所有的算法作用，才能动态的去调用。

    我把上面示例修改了一下，结合简单工厂模式可以弥补不足。

结合简单工厂模式：

修改后的Context：

public class Context {
    private Strategy strategy;

    public Context(String type){
        if ("加".equals(type)){
            strategy = new OperationAdd();
        }else if ("减".equals(type)){
            strategy = new OperationSubstract();
        }else {
            strategy = new OperationMultiply();
        }
    }

    public int executeStrategy(int num1, int num2){
        return strategy.doOperation(num1, num2);
    }
}

main方法类：

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context("加");
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context("减");
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context("乘");
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

我们来总结一下吧：

 

优点： 

1 算法可以自由的切换。
2 使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护。
3 扩展性良好，可以在现有的系统中任意的加入新的策略，只需实现策略接口，符合开闭原则。

缺点： 

1 策略类数量增多，每个策略都是一个类，复用的可能性很小，类数量增多
2 所有的策略都需要对外暴露，上层模块必须知道有哪些策略，然后才能知道采用哪种策略，可以通过使用工厂方法模式、代理模式和享元模式修正。

参考链接：

http://www.runoob.com/design-pattern/strategy-pattern.html

http://www.cnblogs.com/liuzhen1995/p/5983642.html

https://blog.csdn.net/zhangliangzi/article/details/52161211