探讨if...else的替代方案_if-elif-else 可以完全替换if嵌套吗-优快云博客

本文链接：https://blog.youkuaiyun.com/csd11311/article/details/120921604

大家在开发过程中，经常会用到if..else..语句，对于分支较少的业务场景来说还好，如果业务分支较多，那if..else..语句就显得非常臃肿，就会大大的影响代码可读性和可维护性。

针对这个问题，笔者就介绍几种if..else的替代方案。

业务需求

假设我们要做一个计算器，实现加减乘除的需求。使用if...else...语句实现代码如下：

public static int calculate(int a, int b, String operator) {
        int result = Integer.MIN_VALUE;
        if ("add".equals(operator)) {
            result = a + b;
        } else if ("multiply".equals(operator)) {
            result = a * b;
        } else if ("divide".equals(operator)) {
            result = a / b;
        } else if ("subtract".equals(operator)) {
            result = a - b;
        }
        return result;
    }

当然也可以使用swith语句实现。

public static int calculateUsingSwitch(int a, int b, String operator) {
        int result = 0;
        switch (operator) {
            case "add":
                result = a + b;
                break;
            case "subtract":
                result = a - b;
            case "divide":
                result = a / b;
                break;
            case "multiply":
                result = a * b;
        }
        return result;
    }

但是随着运算条件越来越多，则实现逻辑的复杂度则会越来越高，同时越来越难维护。

重构方案

1.工厂模式

创建一个工厂方法，返回一个给定类型的对象，并根据具体对象的操作行为来执行操作。

1.将操作抽象成一个Operation接口。

public interface Operation {
    int apply(int a, int b);
}

2.分别实现加减乘除四个方法。

public class Addition implements Operation {

    @Override
    public int apply(int a, int b) {
        return a + b;
    }
}

public class Division implements Operation{
    @Override
    public int apply(int a, int b) {
        return a - b;
    }
}

// other case

然后通过操作工厂提供加减乘除操作。

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class OperatorFactory {
    static Map<String, Operation> operationMap = new HashMap<>();
    static {
        operationMap.put("add", new Addition());
        operationMap.put("divide", new Division());
        // more operators
    }

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

3.调用

public int calculateUsingFactory(int a, int b, String operator) {
    Operation targetOperation = OperatorFactory
      .getOperation(operator)
      .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
    return targetOperation.apply(a, b);
}

新增运算操作只需要维护操作工厂的operationMap即可。

2.使用枚举

除了使用Map之外，还可以使用Enum来标记业务逻辑。

我们需要定义加减乘除的Enum。

public enum Operator {
    ADD, MULTIPLY, SUBTRACT, DIVIDE
}

枚举表示不同运算符操作，为每个Enum值定义运算操作。例如

ADD {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
},
// other operators

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

在计算器类中，可以定义一个方法来执行该操作。

public int calculate(int a, int b, Operator operator) {
    return operator.apply(a, b);
}

3. 可以通过使用Operator#valueOf()方法将字符串值转换为操作符来调用该方法。

@Test
public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
    assertEquals(7, result);
}

3.命令模式

在前面的讨论中，使用工厂类为给定的操作返回业务对象的实例。还可以设计一个Calculator#calculate方法来接受一个可以在输入端执行的命令。这是替代嵌套if语句的另一种方式—命令模式。

定义命令接口

public interface Command {
    Integer execute();
}

来实现一个加法运算类AddCommand。

public class AddCommand implements Command {
    // Instance variables

    public AddCommand(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public Integer execute() {
        return a + b;
    }
}

在计算器中引入一个新方法，接受并执行命令。

public int calculate(Command command) {
    return command.execute();
}

实例一个AddCommand，并将其传递给Calculator#calculate方法。

@Test
public void whenCalculateUsingCommand_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(new AddCommand(3, 7));
    assertEquals(10, result);
}

4.规则引擎

当我们写下大量嵌套的if语句时，每个条件都描述了一条业务规则，以获得正确的逻辑处理。可以使用一个规则引擎降低将这种代码的复杂性。规则引擎对规则进行评估，并根据输入返回结果。来通过一个例子，设计一个简单的RuleEngine，通过一组规则来处理一个表达式，并返回所选规则的结果。

定义一个规则接口。

public interface Rule {
    boolean evaluate(Expression expression);
    Result getResult();
}

2. 实现一个RuleEngine。

public class RuleEngine {
    private static List<Rule> rules = new ArrayList<>();

    static {
        rules.add(new AddRule());
    }

    public Result process(Expression expression) {
        Rule rule = rules
          .stream()
          .filter(r -> r.evaluate(expression))
          .findFirst()
          .orElseThrow(() -> new IllegalArgumentException("Expression does not matches any Rule"));
        return rule.getResult();
    }
}

规则引擎接受一个表达式对象并返回结果，把表达式类设计成由两个整数对象和将被应用的运算符组成的一组。

public class Expression {
    private Integer x;
    private Integer y;
    private Operator operator;        
}

定义一个自定义的AddRule类，它只在指定ADD操作时进行评估。

public class AddRule implements Rule {
    @Override
    public boolean evaluate(Expression expression) {
        boolean evalResult = false;
        if (expression.getOperator() == Operator.ADD) {
            this.result = expression.getX() + expression.getY();
            evalResult = true;
        }
        return evalResult;
    }    
}