传统模式

创建一个接口

public interface Stratery {
    public int doSomething(int i,int j);
}

创建该接口的不同实现类

public class DoSub implements Stratery{
    @Override
    public int doSomething(int i, int j) {
        return i-j;
    }
}

public class DoAdd implements Stratery{
    @Override
    public int doSomething(int i, int j) {
        return i+j;
    }
}

创建context类

public class StrategyContext {
    private Stratery stratery;
    public StrategyContext(Stratery stratery){
        this.stratery=stratery;
    }
    public int execute(int i,int j){
        return stratery.doSomething(i,j);
    }
}

测试

    @Test
    void strategyTest() {
        StrategyContext strategyContext = new StrategyContext(new DoAdd());
        System.out.println(strategyContext.execute(1, 2));
        StrategyContext strategyContext1 = new StrategyContext(new DoSub());
        System.out.println(strategyContext1.execute(2, 1));
    }

函数式口Function+map

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public class StrategyTest1 {
    private static Map<String, Function<String,String>> resultDispatcherMuti = new HashMap<>();

    static {
        resultDispatcherMuti.put("校验1",order -> String.format("对%s执行业务逻辑1", order));
        resultDispatcherMuti.put("校验2",order->String.format("对%s执行业务逻辑2", order));
        resultDispatcherMuti.put("校验3",order->String.format("对%s执行业务逻辑3", order));
        resultDispatcherMuti.put("校验4",order->String.format("对%s执行业务逻辑4", order));
    }

    public static String getResultDispatcher(String order) {
        Function<String, String> result = resultDispatcherMuti.get(order);
        if (result!=null) {
           return result.apply(order);
        }
        return "不在处理的业务中返回逻辑错误";
    }

    public static void main(String[] args) {
        String result = getResultDispatcher("校验1");
        System.out.println(result);
    }
}

枚举

package com.example.shiyan.desingPattern;
@SuppressWarnings("all")
public enum CalculatorEnum {

    ADD("+") {
        @Override
        public int exec(int a, int b) {
            return a + b;
        }
    },
    SUB("-") {
        @Override
        public int exec(int a, int b) {
            return a - b;
        }
    };

    CalculatorEnum(String s) {
        this.value = s;
    }

    private final String value;

    public abstract int exec(int a, int b);
}

测试

    @Test
    public void testCalculatorEnum() {
        int addResult = CalculatorEnum.ADD.exec(1, 3);
        int subResult = CalculatorEnum.SUB.exec(2, 1);
        System.out.println(addResult+"====="+subResult);
    }