设计模式之策略模式浅谈

设计模式之 策略模式浅谈

-定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

Context叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

举个栗子： 一天经理看到小王写了一段要上线测试的代码：

	public int calculate(int numOne,int numTwo,String type){
        int result = 0;
        if ("+".equals(type)) {
            result = numOne + numTwo;
        } else if ("-".equals(type)) {
            result = numOne - numTwo;
        } else if ("*".equals(type)) {
            result = numOne * numTwo;
        }
        return result;
    }

经理说：小王啊，如果用户哪天想让咱们做一个除法的功能怎么办呢，是不是又要及时修改代码呢，到时候代码越来越长，判断越来越多，越来越难管理维护了。不如用策略模式去解决这个问题吧！
后边小王就找书籍看到了一个图，就用

（引用了度娘图库的一张图）
这里很显然，Context是这里的上下文环境，封装了Strategy这个抽象策略类（其实是个接口，因为策略模式主要针对的是不同策略对象的行为，也就是重写的方法），而ConcreteStrategyA，B，C这三个类被称为具体策略类，也就是三种不同的解决用户问题的解决方式。
于是乎小王就修改了自己的代码

/**
 * 抽象策略类
 */
public interface Strategy {

    public int compute(int numOne,int numTwo);

}
//============================================================
/**
 * 具体策略类 ：乘法
 */
public class ComputeToMultiplication implements Strategy{
    public int compute(int numOne, int numTwo) {
        return numOne * numTwo;
    }
}
//============================================================
/**
 * 具体策略类：减法
 */
public class ComputeToSub implements Strategy {

    public int compute(int numOne, int numTwo) {
        return numOne - numTwo;
    }
}
//============================================================
/**
 * 封装策略类的上下文对象
 */
public class Context {

    private Strategy strategy;
    
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    
    public int contextCompute(int num1, int num2){
        return strategy.compute(num1, num2);
    }
}

public class demo {

	 public static void main(String[] args) {
		//调用减法算法的策略
        Context context1 = new Context(new ComputeToSub());
        int result1 = context1.contextCompute(10,8);
        System.out.println("调用减法结果为:" + result1);
		//调用乘法算法的策略
        Context context2 = new Context(new ComputeToMultiplication());
        int result2 = context2.contextCompute(10,8);
        System.out.println("调用乘法结果为:" + result2);
    }
}

小王写完了发现：策略模式成功把这几个算法需求分成了不同的策略类趋势线。也发现了策略模式的好处。
好处：

• 解决了曾经一段代码不同if-else去判断调用方法实现的臃肿；
• 符合面向对象的开闭原则，实现了代码之间的解耦，扩展性更高，当需要添加别的算法需求时，可以扩展更多的具体策略类。

缺点：

• 策略模式会出现很多的策略类。
• 所有具体策略类要对外暴露，要让客户知道需要采用哪种策略方式去实现。

应用场景：

• 上边咱们用到的就是我们需要在算法或者行为中选择一种去实现
• 系统有很多的类，他们之间的区别主要在于他们的方法行为，我们就可以完全把他们做成一个策略模式。