设计模式之策略模式（排除过多的if-else，且无需反射和注解的实现方式）

1.设计模式选型---行为型（策略模式），为消除if-else 实现代码的松耦合而存在

2.思路：将行为的决策权交给枚举，有多少种情况就需要定义多少个枚举类型，匹配时根据枚举类型中的键值进行决策。

3.talk is cheap, show me the code

4.代码实现：

4.1定义一个超级父类SuperInterface，多个策略模式时可直接拿来复用：

import java.util.List;

/**
 * 策略模式最顶层的父类
 * @author HUAWEI
 *
 */
public interface SuperInterface {

    public Object doOperation(List objs);

}

4.2.定义业务具体实现，此处借用加减操作进行封装（OperationAdd）

import java.util.List;

public class OperationAdd implements SuperInterface {

    private static OperationAdd add = null;

    private OperationAdd(){}
    
    public static OperationAdd getInstance(){
        if(add == null){
            synchronized (OperationAdd.class) {
                add = new OperationAdd();
            }
        }
        return add;
    }
    @Override
    public Object doOperation(List objs) {
        double sum = 0;
        for(Object obj:objs){
            double temp = Double.valueOf(obj.toString());
            sum += temp;
        }
        return sum;
    }

}

4.3.定义业务具体实现，此处借用加减操作进行封装（OperationSub）

import java.util.List;

public class OperationSub implements SuperInterface {


    private OperationSub(){}
    
    private static OperationSub sub = null;
    
    public static OperationSub getInstance(){
        if(sub == null){
            synchronized (OperationSub.class) {
                sub = new OperationSub();
            }
        }
        return sub;
    }
    @Override
    public Object doOperation(List objs) {
        double First = Double.valueOf(objs.get(0).toString());
        int i=0;
        for(Object d:objs){
            if(i == 0){
                i =1;
                continue;
            }
            double temp = Double.valueOf(d.toString());
            First -= temp;
        }
        return First;
    }

}

4.4.枚举类定义（OperType）

public enum OperType {

    ADD(1,OperationAdd.getInstance()),SUB(2,OperationSub.getInstance());
    private Integer code;
    private SuperInterface option;
    private OperType(Integer code,SuperInterface option){
        this.setCode(code);
        this.setOption(option);
    }
    public SuperInterface getOption() {
        return option;
    }
    public void setOption(SuperInterface option) {
        this.option = option;
    }
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
}

4.5.业务具体类（test）

import java.util.HashMap;
import java.util.Map;

import net.sf.json.JSONArray;




public class test {

    public static void main(String[] args) {
        Map request = new HashMap<String, String>();
        request.put("type", "SUB");
        request.put("data", "[100,20,30]");
        doOperation(request);
    }
    
    public static void doOperation(Map<String,String> request){
        try{
            String type = request.get("type");
            String data = request.get("data");
            JSONArray array = JSONArray.fromObject(data);
            OperType optype = OperType.valueOf(type);
            SuperInterface add = optype.getOption();
            Object res = add.doOperation(array);
            System.out.println("add res:"+res);
        }catch(Exception e){
            System.out.println("执行出错");
            e.printStackTrace();
        }
    }
}

5.说明:具体类实现时用到了单例模式，避免多次实例化造成内存浪费，使用枚举有些类似switch形式，但是具体匹配需要交给前端传值来调用，情况过多时前后台交互的情况过多，不利于前端代码的更改