大家在开发过程中，经常会用到 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);
}
可以通过使用 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();
}
-
实现一个 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;
}
}
用一个表达式来调用 RuleEngine。
@Test
public void whenNumbersGivenToRuleEngine_thenReturnCorrectResult() {
Expression expression = new Expression(5, 5, Operator.ADD);
RuleEngine engine = new RuleEngine();
Result result = engine.process(expression);
assertNotNull(result);
assertEquals(10, result.getValue());
}
总结
当然，嵌套 if 的替代方法不止这些，这里抛砖引玉，大家可以发散脑洞，欢迎留言更多替代方案哦。
赞，很实用