如何简化含3个不同else分支的箭头型if语句？

先看看你给出的原始代码：

if(condition1)
    if(condition2) {
        if(condition3) {
                      //do something if the 3 conditions are met
        }
        else {
              //do something if condition 3 is NOT met      
        }   
    }
    else{
                //do something if condition 2 is NOT met
        }               
else{
        //do something if condition 1 is NOT met
}

这段代码最大的问题是嵌套层级太深，而且每个分支的业务逻辑都不一样，后续要加新条件或者改分支逻辑时，很容易搞乱原有结构。下面是几种针对这种场景的实用重构方法，专门解决多分支逻辑各异的维护痛点：

1. 用卫语句扁平化结构 #

把不满足条件的分支提前处理，直接执行逻辑后返回，把嵌套的层级拆成线性的判断，可读性立马提升：

// 先处理condition1不满足的情况，直接执行逻辑
if (!condition1) {
    //do something if condition 1 is NOT met
    return; // 没后续逻辑就直接结束，避免继续往下走
}

// 再处理condition2不满足的情况
if (!condition2) {
    //do something if condition 2 is NOT met
    return;
}

// 最后处理condition3的两种情况
if (condition3) {
    //do something if the 3 conditions are met
} else {
    //do something if condition 3 is NOT met
}

这种方式适合分支逻辑代码量不大的场景，新增条件时只需在对应位置加个卫语句就行，不会打乱原有结构。

2. 策略模式封装独立分支逻辑 #

如果每个分支的业务逻辑复杂、代码行数多，而且未来可能要加更多分支，就用策略模式把每个分支的逻辑单独封装成类，把条件判断和具体逻辑拆开：

首先定义一个策略接口：

interface ConditionHandler {
    void handle();
}

然后给每个分支写具体的实现类：

class HandleCondition1NotMet implements ConditionHandler {
    @Override
    public void handle() {
        //do something if condition 1 is NOT met
    }
}

class HandleCondition2NotMet implements ConditionHandler {
    @Override
    public void handle() {
        //do something if condition 2 is NOT met
    }
}

class HandleAllConditionsMet implements ConditionHandler {
    @Override
    public void handle() {
        //do something if the 3 conditions are met
    }
}

class HandleCondition3NotMet implements ConditionHandler {
    @Override
    public void handle() {
        //do something if condition 3 is NOT met
    }
}

最后在主逻辑里匹配对应的处理类执行：

ConditionHandler handler;

if (!condition1) {
    handler = new HandleCondition1NotMet();
} else if (!condition2) {
    handler = new HandleCondition2NotMet();
} else if (condition3) {
    handler = new HandleAllConditionsMet();
} else {
    handler = new HandleCondition3NotMet();
}

handler.handle();

这样改完之后，要加新分支只需要新增一个实现类，不用动原来的判断逻辑，完全不会影响旧代码，适合业务逻辑复杂、需要频繁扩展的场景。

3. 表驱动法简化条件匹配 #

如果条件组合的规则很明确，可以把“条件组合”和“对应逻辑”做成键值对的映射表，通过查表直接执行逻辑：

// 先把所有条件组合和对应的逻辑存进Map里
Map<List<Boolean>, Runnable> conditionActionMap = new HashMap<>();
// 键是[condition1, condition2, condition3]的布尔值组合，值是要执行的逻辑
conditionActionMap.put(Arrays.asList(false, false, false), () -> {
    //do something if condition 1 is NOT met
});
conditionActionMap.put(Arrays.asList(true, false, false), () -> {
    //do something if condition 2 is NOT met
});
conditionActionMap.put(Arrays.asList(true, true, true), () -> {
    //do something if the 3 conditions are met
});
conditionActionMap.put(Arrays.asList(true, true, false), () -> {
    //do something if condition 3 is NOT met
});

// 生成当前的条件组合
List<Boolean> currentConditions = Arrays.asList(condition1, condition2, condition3);
// 直接查表执行逻辑
conditionActionMap.get(currentConditions).run();

这种方式把条件判断变成了查表操作，逻辑一目了然，新增条件组合时只需要往Map里加新的键值对就行，适合条件组合清晰、分支逻辑相对简洁的场景。

内容的提问来源于stack exchange，提问作者Sergio López López