使用FunctionInterface去除ifelse判断

在实际开发中我们难免会遇到更具不同的条件去执行不同的方法，当条件和方法太多的话，一般会使用大量的ifelse去判断和执行方法，这样一来不利于阅读，也不太美观，例如：

public String functionOne(Integer affair){
        System.out.println("方法一执行");
        return "方法一执行结果："+affair;
    }

    public String functionTwo(Integer affair){
        System.out.println("方法二执行");
        return "方法二执行结果："+affair;
    }

    public String functionThree(Integer affair){
        System.out.println("方法三执行");
        return "方法三执行结果："+affair;
    }

    public void actuator(FunctionEnum functionEnum){
        if(functionEnum==FunctionEnum.FUNCTION_ONE){
            System.out.println(functionOne(functionEnum.getValue()));
        }else if(functionEnum==FunctionEnum.FUNCTION_TWO){
            System.out.println(functionTwo(functionEnum.getValue()));
        }else if(functionEnum==FunctionEnum.FUNCTION_THREE){
            System.out.println(functionThree(functionEnum.getValue()));
        }
    }

    public static void main(String[] args) {
        FunctionTest functionTest=new FunctionTest();
        functionTest.actuator(FunctionEnum.FUNCTION_ONE);
    }

可以看出上边的actuator方法会根据枚举FunctionEnum的值去执行不同的方法，当ifelse太多的话就不太美观了，那么我们可以用FunctionInterface来优化代码，这里就不介绍FunctionInterface了，有兴趣小伙伴自己去看看，直接贴优化后的代码：

  Map<FunctionEnum, Function<Integer,String>> affairFunctionS = new HashMap<>();

    FunctionTest(){
        affairFunctionS.put(FunctionEnum.FUNCTION_ONE, this::functionOne);
        affairFunctionS.put(FunctionEnum.FUNCTION_TWO, this::functionTwo);
        affairFunctionS.put(FunctionEnum.FUNCTION_THREE, this::functionThree);
    }

    public String functionOne(Integer affair){
        System.out.println("方法一执行");
        return "方法一执行结果："+affair;
    }

    public String functionTwo(Integer affair){
        System.out.println("方法二执行");
        return "方法二执行结果："+affair;
    }

    public String functionThree(Integer affair){
        System.out.println("方法三执行");
        return "方法三执行结果："+affair;
    }

    public void actuator(FunctionEnum functionEnum){
        Function<Integer, String> function =affairFunctionS.get(functionEnum);
        System.out.println(function.apply(functionEnum.getValue()));
    }

    public static void main(String[] args) {
        FunctionTest functionTest=new FunctionTest();
        functionTest.actuator(FunctionEnum.FUNCTION_ONE);
    }

执行main方法：

完美执行，再换个枚举值试试

 public static void main(String[] args) {
        FunctionTest functionTest=new FunctionTest();
        functionTest.actuator(FunctionEnum.FUNCTION_TWO);
    }

执行结果

可以完美达到预期结果，甚至还可以直接使用Lambda去省略掉functionOne等方法的定义

Map<FunctionEnum, Function<Integer,String>> affairFunctionS = new HashMap<>();

    FunctionTest(){
        affairFunctionS.put(FunctionEnum.FUNCTION_ONE,(Integer affair)->{
            System.out.println("方法一执行");
            return "方法一执行结果："+affair;
        });
        affairFunctionS.put(FunctionEnum.FUNCTION_TWO, (Integer affair)->{
            System.out.println("方法二执行");
            return "方法二执行结果："+affair;
        });
        affairFunctionS.put(FunctionEnum.FUNCTION_THREE, (Integer affair)->{
            System.out.println("方法三执行");
            return "方法三执行结果："+affair;
        });
    }

    public void actuator(FunctionEnum functionEnum){
        Function<Integer, String> function =affairFunctionS.get(functionEnum);
        System.out.println(function.apply(functionEnum.getValue()));
    }

    public static void main(String[] args) {
        FunctionTest functionTest=new FunctionTest();
        functionTest.actuator(FunctionEnum.FUNCTION_ONE);
    }

这样一来，代码更加简洁，还可以通过策略工厂模式，责任链模式去除ifelse的嵌套，有机会再写