多重if替换方式

public class Test {


    public static void main(String[] args) {
        List<Order> list = Lists.newArrayList();
        Order order = null;
        Optional.ofNullable(order).ifPresent( list::add );

        System.out.println(JSON.toJSONString(list));

        Calculator calculator = new Calculator();
        /****** 方式一 ******/
        int add = calculator.calculateUsingFactory(6, 2, "add");
        System.out.println("add result = "+ add);
        int divide = calculator.calculateUsingFactory(6, 2, "divide");
        System.out.println("divide result = "+ divide);
        System.out.println("--------------------------------------------");
        /****** 方式二 ******/
        int add2 = calculator.calculate(6, 2, Operator.ADD);
        System.out.println("add result = "+ add2);
        int divide2 = calculator.calculate(6, 2, Operator.DIVIDE);
        System.out.println("divide result = "+ divide2);
    }

    public static class Calculator {
        /****** 方式一 ******/
        public int calculateUsingFactory(int a, int b, String operator) {
            Operation targetOperation = OperatorFactory
                    .getOperation(operator)
                    .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
            return targetOperation.apply(a, b);
        }

        /****** 方式二 ******/
        public int calculate(int a, int b, Operator operator) {
            return operator.apply(a, b);
        }
    }

    /***************************** 方式一 *****************************/
    /**
     * 定义一个操作接口
     **/
    public interface Operation {
        int apply(int a, int b);
    }

    /**
     * 加法 实现操作，
     **/
    static class Addition implements Operation {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    }

    /**
     * 除法 实现操作，
     **/
    static class Division implements Operation {
        @Override
        public int apply(int a, int b) {
            return a / b;
        }
    }

    /**
     * 实现操作工厂
     **/
    static class OperatorFactory {
        static Map<String, Operation> operationMap = new HashMap<>();
        static {
            operationMap.put("add", new Addition());
            operationMap.put("divide", new Division());
            // 更多实现操作...
        }

        public static Optional<Operation> getOperation(String operator) {
            return Optional.ofNullable(operationMap.get(operator));
        }
    }

    /***************************** 方式一 *****************************/

    /***************************** 方式二 *****************************/
    public enum Operator {
        ADD {
            @Override
            public int apply(int a, int b) {
                return a + b;
            }
        },
        DIVIDE {
            @Override
            public int apply(int a, int b) {
                return a / b;
            }
        };
        // 更多实现操作...

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


    /***************************** 方式二 *****************************/

}