if-else 判断语句过多该如何处理？
我们平时在写代码的语句时候，if-else判断语句基本上必不可少，过多该何当我们的处理判断语句只有一两层的时候，类似下面这种，判断情况还好，语句基本上能接受;
if(condition){
doSomeThing();
.jpg)
} else {
.jpg)
doSomeThing();
}但是过多该何当过度的使用if-else的时候，会对代码的处理可读性、可扩展性造成负面影响，判断比如类似下面这个!
if(condition1){
if(condition2){
if(condition3){
if(condition4){
if(condition5){
if(condition6){
doSomeThing();
}
}
}
}
}
}如果判断语句越来越多，语句后期进行项目维护也会比较困难，过多该何对于后面接手项目的处理人来说，会是判断一个很头疼的问题了。
因此，语句如何去除掉代码中过多的过多该何if...else语句，反映的是程序员对软件重构、设计模式、面向对象设计、架构模式、数据结构等多方面技术的综合运用能力。高防服务器
那问题来了，如何解决代码中过多的if...else语句呢?下面一起来聊聊有效的几种解决方案!
二、解决方案
首先，我们编写一个简单的程序计算器，代码如下!
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;
}以上文为案例，我们一起来看看，可以对其进行改造的几种方式!
2.1、适时的 return如果if里面条件判断比较单一又互斥的，我们可以在合适的位置直接return，废除掉else代码，比如将其改造成如下方式：
public int calculate(int a, int b, String operator) {
if ("add".equals(operator)) {
return a + b;
}
if ("subtract".equals(operator)) {
return a - b;
}
if ("multiply".equals(operator)) {
return a * b;
}
if ("divide".equals(operator)) {
return a / b;
}
return 0;
}代码瞬间是不是清晰了很多!
2.2、引入策略模式进行改造但是当if判断逻辑内容非常复杂的时候，以上的方案就有点不够优雅了，这个时候，我们可以将if判断逻辑独立成类来单独处理，操作方法如下!
首先，我们定义一个Operation接口，用于逻辑的计算public interface Operation {
/
*** 执行计算
* @param a
* @param b
* @return
*/
int execute(int a, int b);
}接着，分别将四个if判断逻辑独立成一个模块，来单独处理public class AddOperation implements Operation {
@Override
public int execute(int a, int b) {
return a + b;
}
}public class SubOperation implements Operation {
@Override
public int execute(int a, int b) {
return a - b;
}
}
public class MultiOperation implements Operation {
@Override
public int execute(int a, int b) {
return a * b;
}
}public class DivOperation implements Operation {
@Override
public int execute(int a, int b) {
return a / b;
}
}然后，网站模板创建一个工厂类，用于处理客户端传入的参数public class OperatorFactory {
private static Map
static {
//初始化实现类
operationMap.put("add", new AddOperation());
operationMap.put("sub", new SubOperation());
operationMap.put("multi", new MultiOperation());
operationMap.put("div", new DivOperation());
// more operators
}
/
*** 获取对应的目标实现类
* @param operator
* @return
*/
public static Optional
return Optional.ofNullable(operationMap.get(operator));
}
}最后，在需要的地方引入方法即可!public class OperatorTestMain {
public static void main(String[] args) {
//获取计算的目标实现类
Operation targetOperation = OperatorFactory
.getOperation("add")
.orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
int result = targetOperation.execute(1, 2);
System.out.println("result:" + result);
}
}至此，if...else方法改造完毕!
2.3、引入规则引擎模式进行改造当方法内部的if...else越来越多的时候，我们可以通过规则引擎模式来消除这种复杂度，具体实践如下!
首先，创建一个规则标准接口Rule，并将条件判断方法进行抽象public interface Rule {
/
*** 检查是否进入规则计算
* @param expression
* @return
*/
boolean evaluate(Expression expression);
/
*** 执行规则计算
* @param expression
* @return
*/
int execute(Expression expression);
}public class Expression {
private Integer a;
private Integer b;
/
*** 计算类型
*/
private String operator;
public Expression(Integer a, Integer b, String operator) {
this.a = a;
this.b = b;
this.operator = operator;
}
}接着，根据每个规则创建不同的计算实现类，以AddRule为例public class AddRule implements Rule {
@Override
public boolean evaluate(Expression expression) {
if ("add".equalsIgnoreCase(expression.getOperator())) {
return true;
}
return false;
}
@Override
public int execute(Expression expression) {
int result = expression.getA() + expression.getB();;
return result;
}
}
然后，创建一个规则引擎，用于逻辑的处理
public class RuleEngine {
private static List
static {
rules.add(new AddRule());
//添加其他的规则计算实现类
}
/
*** 执行规则计算
* @param expression
* @return
*/
public int process(Expression expression){
Rule rule = rules
.stream()
.filter(r -> r.evaluate(expression))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException("Expression does not matches any Rule"));
return rule.execute(expression);
}
}最后，在需要的地方引入方法即可!
public class RuleEngineTestMain {
public static void main(String[] args) {
Expression expression = new Expression(1, 2, "add");
RuleEngine engine = new RuleEngine();
int result = engine.process(expression);
System.out.println("result:" + result);
}
}规则引擎和策略模式，最大的不同的就是将条件逻辑判断抽象化，由具体的实现类来判断是不是满足要求，香港云服务器如果满足要求，就执行;否则不执行!
三、Spring 集成应用
可能有的同学会发出疑问，以上介绍的都是原生的处理办法，在当下处处都集成了Spring框架的项目，我们应该如何使用呢?
下面我们以上面提到的《引入策略模式进行改造》为例，如果在Spring里面，我们应该如何应用?
3.1、Spring 策略模式实现介绍(方案一)首先，我们还是定义一个Command接口，用于方法的抽象和统一public interface Command {
/
*** 命令类型
* @return
*/
String operateType();
/
*** 执行
* @param a
* @param b
* @return
*/
Integer execute(int a, int b);
}接着，编写四套不同的计算处理逻辑@Component
public class AddCommand implements Command {
@Override
public String operateType() {
return "add";
}
@Override
public Integer execute(int a, int b) {
return a + b;
}
}@Component
public class SubCommand implements Command {
@Override
public String operateType() {
return "subtract";
}
@Override
public Integer execute(int a, int b) {
return a - b;
}
}@Component
public class MultiCommand implements Command {
@Override
public String operateType() {
return "multiply";
}
@Override
public Integer execute(int a, int b) {
return a * b;
}
}@Component
public class DivCommand implements Command {
@Override
public String operateType() {
return "divide";
}
@Override
public Integer execute(int a, int b) {
return a / b;
}
}然后，编写一个类似于上文的策略处理类@Component
public class CalculatorService implements ApplicationContextAware {
private Map
/
*** 执行计算
* @param operateType
* @param a
* @param b
* @return
*/
public int calculate(String operateType,int a, int b){
Command targetCommand = Optional.ofNullable(commandMap.get(operateType))
.orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
return targetCommand.execute(a,b);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
Map
tempMap.values().forEach(source -> commandMap.put(source.operateType(), source));
}
}最后，我们只需要在适当的位置应用即可!@RunWith(SpringRunner.class)
@SpringBootTest
public class CalculatorServiceTest {
@Autowired
private CalculatorService calculatorService;
@Test
public void test(){
int result = calculatorService.calculate("add", 1,2);
System.out.println("result:" + result);
}
}3.2、Spring 策略模式实现介绍(方案二，推荐)翻查Spring的ioc容器，你会发现一个秘密，当一个接口有多个实现类时，Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类。
简单的说，我们只需要通过@Autowired注入对象，不需要通过CalculatorService这个类进行单独配置，操作方式如下!
首先，编写一个CommandFactory工厂类，用于逻辑的处理@Component
public class CommandFactory {
/
*** Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类
*/
@Autowired
private Map
/
*** 执行计算
* @param operateType
* @param a
* @param b
* @return
*/
public int calculate(String operateType,int a, int b){
Command targetCommand = Optional.ofNullable(commandMap.get(operateType))
.orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
return targetCommand.execute(a,b);
}
}最后，直接在合适的地方使用CommandFactory即可!@RunWith(SpringRunner.class)
@SpringBootTest
public class CalculatorServiceTest {
@Autowired
private CommandFactory commandFactory;
@Test
public void test(){
int result = commandFactory.calculate("addCommand", 1,2);
System.out.println("result:" + result);
}
}四、小结
本文主要围绕如何解决if...else...过多问题进行一些总结和案例分享，期望能对大家有所帮助!
五、参考
1、baeldung java-replace-if-statements
2、知乎 - 如何去除代码中过多的if语句