設計模式之策略模式（排除過多的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形式，但是具體匹配需要交給前端傳值來調用，情況過多時前后台交互的情況過多，不利於前端代碼的更改