Java设计模式之策略模式

模式定义
策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

使用场景
1.针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。
2.需要安全的封装多种同一类型的操作时。
3.出现同一抽象多个子类，而又需要使用if-else 或者 switch-case来选择时。

Context：用来操作策略的上下文环境。
Strategy : 策略的抽象。
ConcreteStrategyA、ConcreteStrategyB : 具体的策略实现。

简单的计算操作(+、-、*、/)作为示例:
未使用策略模式

public static double calc(String op, double paramA, double paramB) {
        if ("+".equals(op)) {
            System.out.println("执行加法...");
            return paramA + paramB;
        } else if ("-".equals(op)) {
            System.out.println("执行减法...");
            return paramA - paramB;
        } else if ("*".equals(op)) {
            System.out.println("执行乘法...");
            return paramA * paramB;
        } else if ("/".equals(op)) {
            System.out.println("执行除法...");
            if (paramB == 0) {
                throw new IllegalArgumentException("除数不能为0!");
            }
            return paramA / paramB;
        } else {
            throw new IllegalArgumentException("未找到计算方法!");
        }
    }

使用策略模式

Calc：进行计算操作的上下文环境。
Strategy : 计算操作的抽象。
AddStrategy、SubStrategy、MultiStrategy、DivStrategy : 具体的 +、-、*、/ 实现。

 //针对操作进行抽象
    public interface Strategy {
        public double calc(double paramA, double paramB);
    }

    //加法的具体实现策略
    public class AddStrategy implements Strategy {
        @Override
        public double calc(double paramA, double paramB) {
            // TODO Auto-generated method stub
            System.out.println("执行加法策略...");
            return paramA + paramB;
        }
    }

    //减法的具体实现策略
    public class SubStrategy implements Strategy {
        @Override
        public double calc(double paramA, double paramB) {
            // TODO Auto-generated method stub
            System.out.println("执行减法策略...");
            return paramA - paramB;
        }
    }

    //乘法的具体实现策略
    public class MultiStrategy implements Strategy {
        @Override
        public double calc(double paramA, double paramB) {
            // TODO Auto-generated method stub
            System.out.println("执行乘法策略...");
            return paramA * paramB;
        }
    }

    //除法的具体实现策略
    public class DivStrategy implements Strategy {
        @Override
        public double calc(double paramA, double paramB) {
            // TODO Auto-generated method stub
            System.out.println("执行除法策略...");
            if (paramB == 0) {
                throw new IllegalArgumentException("除数不能为0!");
            }
            return paramA / paramB;
        }
    }

    //上下文环境的实现
    public class Calc {
        private Strategy strategy;
        public void setStrategy(Strategy strategy) {
            this.strategy = strategy;
        }

        public double calc(double paramA, double paramB) {
            // TODO Auto-generated method stub
            // doing something
            if (this.strategy == null) {
                throw new IllegalStateException("你还没有设置计算的策略");
            }
            return this.strategy.calc(paramA, paramB);
        }
    }


    //执行方法
    public static double calc(Strategy strategy, double paramA, double paramB) {
        Calc calc = new Calc();
        calc.setStrategy(strategy);
        return calc.calc(paramA, paramB);
    }

测试方法
  public static void main(String[] args) {
        double paramA = 5;
        double paramB = 21;

        System.out.println("------------- 普通形式 ----------------");
        System.out.println("加法结果是：" + calc("+", paramA, paramB));
        System.out.println("减法结果是：" + calc("-", paramA, paramB));
        System.out.println("乘法结果是：" + calc("*", paramA, paramB));
        System.out.println("除法结果是：" + calc("/", paramA, paramB));

        System.out.println("------------ 策略模式 ----------------");
        System.out.println("加法结果是：" + calc(new AddStrategy(), paramA, paramB));
        System.out.println("减法结果是：" + calc(new SubStrategy(), paramA, paramB));
        System.out.println("乘法结果是：" + calc(new MultiStrategy(), paramA, paramB));
        System.out.println("除法结果是：" + calc(new DivStrategy(), paramA, paramB));
    }

优点
结构清晰明了、使用简单直观。
耦合度相对而言较低，扩展方便。
操作封装也更为彻底，数据更为安全。

缺点
随着策略的增加，子类也会变得繁多。

参考书籍:
Android设计模式源码解析