1.前言
项目开发初期阶段 if/else 语句一般比较简单，然后随着时间的推移和业务量的增加，if/else 分之会越来越长。下面对如何重构 if/else 做出了详细分析。
2.案例研究
我们经常遇到涉及很多条件的业务逻辑，并且每个都需要不同的处理，我们以 Calculator 类作为演示样例。有一个方法，它接受两个数字和一个运算符作为输入项，并根据操作返回相应结果：
public 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;}
我们也可以使用 switch 语句来实现它：
public int calculateUsingSwitch(int a, int b, String operator) {
switch (operator) {
case "add":
result = a + b;
break;
// other cases
}
return result;}
在真正的项目开发中，if 语句可能会变得更大，更复杂，这时候 switch 语句并不是很适合，下面将介绍更好模式来解决 if/else 问题。
3.重构
3.1 工厂类
if/else 每个分支中执行类似的操作,我们通过工厂方法返回给指定类型的对象并基于具体对象行为执行操作。
让我们定义一个具有单个 apply 方法的 Operation 接口：
public interface Operation {
int apply(int a, int b);}
该方法将两个数字作为输入并返回结果。让我们定义一个用于执行添加的类：
public class Addition implements Operation {
@Override
public int apply(int a, int b) {
return a + b;
}}我们现在将实现一个工厂类，它根据给定的运算符返回 Operation 的实例：
public class OperatorFactory {
static Map operationMap = new HashMap<>();
static {
operationMap.put("add", new Addition());
operationMap.put("divide", new Division());
// more operators }
public static Optional getOperation(String operator) {
return Optional.ofNullable(operationMap.get(operator));
}}
现在，在 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);}
在这个例子中，我们已经看到了如何将责任委托给工厂类提供的松散耦合对象，但是有可能嵌套的 if 语句只是转移到了工厂类，java培训我们可以在 Map 中维护一个对象存储库，可以查询该存储库以进快速查找，所以设计了 OperatorFactory 中的 operationMap 对象。
3.2 使用枚举
除了使用 Map 之外，我们还可以使用 Enum 来标记特定的业务逻辑。之后，我们可以在嵌套的 if 语句或 switch case 语句中使用它们。或者，我们也可以将它们用作对象的工厂并制定策略以执行相关的业务逻辑。这样可以减少嵌套 if 语句的数量并委托给单个 Enum 值。
让我们看看我们如何实现它。首先，我们需要定义我们的枚举：
public enum Operator {
ADD, MULTIPLY, SUBTRACT, DIVIDE}我们可以选择在嵌套的 if 语句或 switch case 中使用枚举值作为不同的条件，下面将介绍一种将逻辑委托给 Enum 本身的替代方法。
首先为每个 Enum 值定义方法并进行计算。例如：
ADD {
@Override
public int apply(int a, int b) {
return a + b;
}},
// other operators
public abstract int apply(int a, int b);
然后在 Calculator 类中，我们可以定义一个可执行操作的方法：
ADD {
@Override
public int apply(int a, int b) {
return a + b;
}},
// other operators
public abstract int apply(int a, int b);
现在，我们可以通过使用 Operator.valueOf（）方法将 String 值转换为 Operator 来调用该方法：
@Test
public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
Calculator calculator = new Calculator();
int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
assertEquals(7, result);}3.3 命令模式
命令模式是解决嵌套 if 语句的另一种方法，我们可以设计一个 Calculator＃calculate 方法来接受可执行的命令。
我们首先定义我们的 Command 接口：
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;
}}
最后，让我们在 Calculator 中引入一个接受并执行 Command 的新方法：
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);}
3.4 规则引擎当我们最终编写大量嵌套 if 语句时，每个条件都描述了一个业务规则，必须对其进行评估才能处理正确的逻辑。规则引擎从主代码中获取了这种复杂性。
让我们通过设计一个简单的 RuleEngine 来进行演示，该 RuleEngine 通过一组规则来处理 Expression，并返回所选规则的结果。
首先，我们将定义一个 Rule 接口：
public interface Rule {
boolean evaluate(Expression expression);
Result getResult();}
其次，让我们实现一个 RuleEngine：
public class RuleEngine {
private static List 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();
}}
所述 RuleEngine 接受一个 Expression 对象并返回结果。
现在，让我们将 Expression 类设计为一组包含两个 Integer 对象的 Operator：
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;
} }
我们现在将使用 Expression 调用 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());}
4 结论
通过上述方法我们重构 if/else 语句不会在仅仅局限于 switch/casef 方式，也探索了用不同的方法来简化复杂的代码和通过使用有效的设计模式来替换嵌套的 if 语句。