策略模式应用

策略（Strategy）模式

本质：分离算法，选择实现。

策略模式：针对一组算法，将每一个算法封装到具有共同接口的独立的类中，使得它们可以互换。

使用策略模式可以把行为和环境分割开来。环境类Context负责查询要做什么，各种算法则在具体策略类（ConcreteStrategy）中提供。
当出现新的促销折扣或现有的折扣政策出现变化时，只需要实现新的策略类，并在客户端登记即可。

代码:

父类:

/**
 * @author zhubayi
 * @Description 基础计算类
 */
public abstract class BaseCalc {
    /**
     * 计算方法
     *
     * @param a
     * @param b
     * @return {@link Integer}
     */
    public abstract Integer calc(Integer a,Integer b);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

AddCalc 加法子类继承BaseCalc 父类，实现计算方法。

/**
 * @author zhubayi
 * @Description 加法
 */
public class AddCalc extends BaseCalc{
    /**
     * 加法
     *
     * @param a
     * @param b
     * @return {@link Integer}
     */
    @Override
    public Integer calc(Integer a, Integer b) {
        return a+b;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

同理减法SubCalc

/**
 * @author zhubayi
 * @Description 减法
 */
public class SubCalc extends BaseCalc{
    /**
     * 减法
     *
     * @param a
     * @param b
     * @return {@link Integer}
     */
    @Override
    public Integer calc(Integer a, Integer b) {
        return a-b;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

工厂类来根据类型调用不同的计算方法。

/**
 * @author zhubayi
 * @Description 工厂类
 */
public class CalcFactory {

    public static final String ADD="add";
    public static final String SUB="sub";
    private static Map<String, BaseCalc> calcMap = new HashMap();
    /**
     * 生产策略产品
     */
    static {
        register(ADD, new AddCalc());
        register(SUB,  new SubCalc());
    }

    /**
     * 注册
     *
     * @param type     类型
     * @param baseCalc 计算父类
     */
    public static void register(String type, BaseCalc baseCalc) {
        if (StringUtils.isEmpty(type) || null == baseCalc) {
            return;
        }
        calcMap.put(type, baseCalc);
    }

    /**
     * 得到调用策略
     *
     * @param type 类型
     * @return {@link BaseCalc}
     */
    public static BaseCalc getInvokeStrategyMap(String type) {
        return calcMap.get(type);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

测试：

加法

public static void main(String[] args) {
        //得到加法计算的策略
        BaseCalc calc = CalcFactory.getInvokeStrategyMap(CalcFactory.ADD);
        //调用方法
        Integer result = calc.calc(1,2);
        //打印结果
        System.out.println(result);
    }
1
2
3
4
5
6
7
8

减法

public static void main(String[] args) {
        //得到减法计算的策略
        BaseCalc calc = CalcFactory.getInvokeStrategyMap(CalcFactory.SUB);
        //调用方法
        Integer result = calc.calc(1,2);
        //打印结果
        System.out.println(result);
    }
1
2
3
4
5
6
7
8