设计模式之策略模式（五）

策略模式

简介

策略模式是指对一系列的算法定义，并将每一个算法封装起来，而且算法之间可以相互替换。策略模式使得算法独立于使用它的客户端。

类图

实现方式

案例场景：实现加/减/乘/除4种运算法则。对于这4种运算场景，其实可以说是4种算法，因此可以使用策略模式使用。其实虽然说是策略模式合适于算法，但是对于其它不同的业务逻辑也是可以使用的不一定说是算法才可以使用。例如：1）商城系统中的各种促销活动，每种促销活动可以是一种算法。2）行政管理系统中的每一种处罚制度可以是一种算法。

Strategy类是策略的抽象类，具体策略的执行是交给context类来执行的。

抽象策略

package com.rabbit.pattern.strategy;

/**
 * 抽象算法策略
 * Created by HASEE on 2018/2/18.
 */
public interface Strategy {

    //策略具体方法
    double doOperation(double num1, double num2);

}

具体策略实现

加法策略

package com.rabbit.pattern.strategy;

/**
 * 具体策略加法
 * Created by HASEE on 2018/2/18.
 */
public class AddStrategy implements Strategy {

    @Override
    public double doOperation(double num1, double num2) {
        return num1 + num2;
    }

}

减法策略

package com.rabbit.pattern.strategy;

/**
 * Created by HASEE on 2018/2/18.
 */
public class SubstractStrategy implements Strategy {
    @Override
    public double doOperation(double num1, double num2) {
        return num1 - num2;
    }
}

策略执行类

package com.rabbit.pattern.strategy;

/**
 * 策略执行类
 * Created by HASEE on 2018/2/18.
 */
public class Context {

    //具体的策略
    private Strategy strategy;

    //构造函数中传入具体策略
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //执行策略
    public double doStrategy(double num1, double num2) {
        return strategy.doOperation(num1, num2);
    }

}

调用方法执行策略

package com.rabbit.pattern.strategy;

/**
 * Created by HASEE on 2018/2/19.
 */
public class Demo {

    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        double result = context.doStrategy(10, 20);
        System.out.println("result = [" + result + "]");
    }

}

优化Context策略执行类

具体的策略可以有无数中，每次调用都需要手动new的方法实例化具体策略，这种方式其实可以使用工厂模式来优化，工厂模式只要解决的就是对象的创建问题。

之前已经讲解过工厂模式可以参考下面的地址学习：

简单工厂模式：http://blog.csdn.net/sinat_32366329/article/details/79285248#t7

工厂方法模式：http://blog.csdn.net/sinat_32366329/article/details/79293825

抽象工厂模式：http://blog.csdn.net/sinat_32366329/article/details/79311751

这里使用简单工厂的反射机制来处理：

package com.rabbit.pattern.strategy;

/**
 * 策略执行类
 * Created by HASEE on 2018/2/18.
 */
public class Context {

    //具体的策略
    private Strategy strategy;

    //私有构造函数
    private Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //结合工厂模式,使用反射机制处理
    public static Context context(Class<? extends Strategy> clazz) {
        try {
            Strategy strategy = clazz.newInstance();
            return new Context(strategy);
        } catch (InstantiationException e) {
            //具体异常是抛出去还是自己处理，根据自己的业务情况处理
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            //具体异常是抛出去还是自己处理，根据自己的业务情况处理
            e.printStackTrace();
        }
        return null;
    }

    //执行策略
    public double doStrategy(double num1, double num2) {
        return strategy.doOperation(num1, num2);
    }

}

通过工厂方法执行策略

package com.rabbit.pattern.strategy;

/**
 * Created by HASEE on 2018/2/19.
 */
public class Demo {

    public static void main(String[] args) {
        Context context = Context.context(AddStrategy.class);
        double result = context.doStrategy(10D, 30D);
        System.out.println("result = [" + result + "]");
    }

}

总结

优点：

1、策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类（策略定义为抽象类而不是接口）里面，从而避免重复的代码。

2、策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。

3、使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。

缺点：

1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

2、策略模式造成很多的策略类，每个具体策略类都会产生一个新类。有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。换言之，可以使用享元模式来减少对象的数量。