Java中多个ifelse语句的替代设计

ifelse是任何编程语言的重要组成部分。但是我们编写了大量嵌套的if语句，这使得我们的代码更加复杂和难以维护。

接下来，让我们探索如何简化代码的中的ifelse语句写法。

案例研究

我们经常遇到涉及很多条件的业务逻辑，并且每个逻辑都需要不同的处理方式。以Calculator类为例。我们将有一个方法，它接受两个数字和一个运算符作为输入，并根据操作返回结果：

publicintcalculate(inta,intb, Stringoperator){intresult = Integer.MIN_VALUE;if("add".equals(operator)) {        result = a + b;    }elseif("multiply".equals(operator)){        result = a * b;    }elseif("divide".equals(operator)){        result = a / b;    }elseif("subtract".equals(operator)){        result = a - b;    }returnresult;}复制代码

我们也可以使用switch语句来实现它：

publicintcalculateUsingSwitch(inta,intb, Stringoperator){switch(operator) {case"add":        result = a + b;break;// other cases    }returnresult;}复制代码

在典型的开发中，if语句可能会变得更大，更复杂。此外，当存在复杂条件时，switch语句不适合。

拥有嵌套决策结构的另一个副作用是它们变得难以管理。例如，如果我们需要添加一个新的运算符，我们必须添加一个新的if语句并实现该操作。

重构

可以通过设计模式，来达到我们要的效果。

工厂模式

很多时候，我们遇到ifelse结构，最终在每个分支中执行类似的操作。这提供了提取工厂方法的机会，该工厂方法返回给定类型的对象并基于具体对象行为执行操作。

对于我们的示例，让我们定义一个具有单个apply方法的Operation接口：

publicinterfaceOperation{intapply(inta,intb);}复制代码

该方法将两个数字作为输入并返回结果。让我们定义一个用于执行添加的类：

publicclassAdditionimplementsOperation{@Overridepublicintapply(inta,intb){returna + b;    }}复制代码

我们现在将实现一个工厂类，它根据给定的运算符返回Operation的实例：

publicclassOperatorFactory{staticMap operationMap =newHashMap<>();static{        operationMap.put("add",newAddition());        operationMap.put("divide",newDivision());// more operators}    publicstaticOptional getOperation(Stringoperator) {returnOptional.ofNullable(operationMap.get(operator));    }}复制代码

现在，在Calculator类中，我们可以查询工厂以获取相关操作并应用源数：

publicintcalculateUsingFactory(inta,intb, Stringoperator){    Operation targetOperation = OperatorFactory      .getOperation(operator)      .orElseThrow(() ->newIllegalArgumentException("Invalid Operator"));returntargetOperation.apply(a, b);}复制代码

在这个例子中，我们已经看到了如何将责任委托给工厂类提供的松散耦合对象。但是有可能嵌套的if语句只是转移到了工厂类，这违背了我们的目的。

或者，我们可以在Map中维护一个对象存储库，可以查询该存储库以进行快速查找。正如我们所见，OperatorFactory＃operationMap服务于我们的目的。我们还可以在运行时初始化Map并将它们配置为查找。

使用枚举

除了使用Map之外，我们还可以使用Enum来标记特定的业务逻辑。之后，我们可以在嵌套的if语句或switch case 语句中使用它们。或者，我们也可以将它们用作对象的工厂并制定策略以执行相关的业务逻辑。

这样可以减少嵌套if语句的数量，并将责任委托给单个Enum值。

让我们看看我们如何实现它。首先，我们需要定义我们的枚举：

publicenumOperator{    ADD, MULTIPLY, SUBTRACT, DIVIDE}复制代码

可以观察到，这些值是不同运算符的标签，将进一步用于计算。我们总是可以选择在嵌套的if语句或switch case中使用这些值作为不同的条件，但让我们设计一种将逻辑委托给Enum本身的替代方法。

我们将为每个Enum值定义方法并进行计算。例如：

ADD {@Overridepublicintapply(inta,intb){returna + b;    }},// other operatorspublicabstractintapply(inta,intb);复制代码

然后在Calculator类中，我们可以定义一个执行操作的方法：

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

现在，我们可以通过使用 Operator＃valueOf() 方法将String值转换为Operator来调用该方法：

@Testpublicvoidtest(){    Calculator calculator =newCalculator();intresult = calculator.calculate(3,4, Operator.valueOf("ADD"));    assertEquals(7, result);}复制代码

命令模式

在前面的讨论中，我们已经看到使用工厂类来返回给定运算符的正确业务对象的实例。稍后，业务对象用于在计算器中执行计算。

我们还可以设计一个Calculator＃calculate方法来接受可以在输入上执行的命令。这将是替换嵌套if语句的另一种方法。

我们首先定义我们的Command接口：

publicinterfaceCommand{Integerexecute();}复制代码

接下来，让我们实现一个AddCommand：

publicclassAddCommandimplementsCommand{// Instance variablespublicAddCommand(inta,intb){this.a = a;this.b = b;    }@OverridepublicIntegerexecute(){returna + b;    }}复制代码

最后，让我们在Calculator中引入一个接受并执行Command的新方法：

publicintcalculate(Command command){returncommand.execute();}复制代码

接下来，我们可以通过实例化AddCommand调用计算并将其发送到Calculator＃calculate方法：

@Testpublicvoidtest(){    Calculator calculator =newCalculator();intresult = calculator.calculate(newAddCommand(3,7));    assertEquals(10, result);}复制代码

规则引擎

当我们最终编写大量嵌套if语句时，每个条件都描述了一个业务规则，必须对其进行评估才能处理正确的逻辑。规则引擎从主代码中获取了这种复杂性。一个 RuleEngine 评估规则和返回基于输入的结果。

让我们通过设计一个简单的RuleEngine来演示一个例子，该RuleEngine通过一组规则处理Expression并返回所选规则的结果。首先，我们将定义一个Rule接口：

publicinterfaceRule{booleanevaluate(Expression expression);ResultgetResult();}复制代码

其次，让我们实现一个RuleEngine：

publicclassRuleEngine{privatestaticList rules =newArrayList<>();static{        rules.add(newAddRule());    }publicResultprocess(Expression expression){        Rule rule = rules          .stream()          .filter(r -> r.evaluate(expression))          .findFirst()          .orElseThrow(() ->newIllegalArgumentException("Expression does not matches any Rule"));returnrule.getResult();    }}复制代码

所述RuleEngine接受一个表达对象，并返回结果。现在，让我们将Expression类设计为一组包含两个Integer对象的Operator，它将被应用：

publicclassExpression{privateInteger x;privateInteger y;privateOperatoroperator;        }复制代码

最后让我们定义一个自定义的AddRule类，该类仅在指定ADD操作时进行求值：

publicclassAddRuleimplementsRule{@Overridepublicbooleanevaluate(Expression expression){booleanevalResult =false;if(expression.getOperator() == Operator.ADD) {this.result = expression.getX() + expression.getY();            evalResult =true;        }returnevalResult;    }    }复制代码

我们现在将使用Expression调用RuleEngine：

@Testpublicvoidtest(){    Expression expression =newExpression(5,5, Operator.ADD);    RuleEngine engine =newRuleEngine();    Result result = engine.process(expression);    assertNotNull(result);    assertEquals(10, result.getValue());}复制代码

结论

通过这些设计模式，可以作为我们的ifelse语句的替代方案，具体用哪一种可以根据你的实际业务场景来决定。

我自己是一个从事了6年的Java全栈工程师，最近整理了一套适合2019年学习的Java\大数据资料，从基础的Java、大数据面向对象到进阶的框架知识都有整理哦，可以来我的主页免费领取哦。