优化if-else的11种方案

优雅永不过时！

1. 使用早返回（Early Return）：尽可能早地返回，避免嵌套的if-else。

优化前：

public class NoEarlyReturnExample {public boolean hasPositiveNumber(int[] numbers) {boolean foundPositive = false;for (int number : numbers) {if (number > 0) {foundPositive = true;// 没有早返回，而是继续循环}}return foundPositive; // 循环结束后返回结果}
}

优化后：

public class EarlyReturnExample {public boolean hasPositiveNumber(int[] numbers) {for (int number : numbers) {if (number > 0) {return true; // 找到正数立即返回}}return false; // 没有找到正数}
}

减少了多次循环

2. 使用三元运算符：在条件简单的情况下，可以使用三元运算符来简化代码。

优化前：

public class NoTernaryOperatorExample {public String getGender(int number) {if (number > 0) {return "girl";} else if (number < 0) {return "boy";} else {return "other";}}
}

优化后：

public class TernaryOperatorExample {public String getGender(int number) {return (number > 0) ? "girl" : (number < 0) ? "boy" : "other";}
}

3. 使用switch-case语句：如果你的条件是基于不同的情况或值，更好的选择是switch-case。

优化前：

public class NoSwitchCaseExample {public void performAction(String action) {if ("start".equals(action)) {System.out.println("Starting...");} else if ("stop".equals(action)) {System.out.println("Stopping...");} else {System.out.println("Unknown action");}}
}

优化后：

public class SwitchCaseExample {public void performAction(String action) {switch (action) {case "start":System.out.println("Starting...");break;case "stop":System.out.println("Stopping...");break;default:System.out.println("Unknown action");}}
}

4. 使用策略模式：将每个条件分支封装成一个策略对象，然后根据条件选择使用哪个策略。

优化前：

public class NoStrategyExample {public void context() {// 没有使用策略模式，而是直接执行代码System.out.println("Direct execution");// do something...}
}

优化后：

public class StrategyExample {interface Strategy {void execute();}public class ConcreteStrategyA implements Strategy {public void execute() {System.out.println("Strategy A executed");}}public void context(Strategy strategy) {strategy.execute();}
}

5. 使用查找表：对于固定数量的条件分支，可以使用查找表（例如字典或哈希表）来映射条件和对应的行为。

优化前：

public class NoLookupTableExample {public void performAction(String action) {// 没有使用查找表，而是使用if-elseif ("start".equals(action)) {System.out.println("Starting...");} else if ("stop".equals(action)) {System.out.println("Stopping...");} else {System.out.println("No action found");}}
}

优化后：

public class LookupTableExample {public void performAction(Map<String, Runnable> actions, String key) {actions.getOrDefault(key, () -> System.out.println("No action found")).run();}
}

6. 使用函数或方法：将每个条件分支的逻辑封装到不同的函数或方法中，然后在if-else中调用这些函数。

优化前：

public class NoFunctionExample {public void handleUserType(String userType) {// 没有使用函数封装，而是直接在if-else中编写逻辑if ("admin".equals(userType)) {System.out.println("Admin logic here");} else if ("user".equals(userType)) {System.out.println("User logic here");} else {System.out.println("Guest logic here");}}
}

优化后：

public class FunctionExample {public void handleUserType(String userType) {if ("admin".equals(userType)) {handleAdmin();} else if ("user".equals(userType)) {handleUser();} else {handleGuest();}}private void handleAdmin() {System.out.println("Handling admin");}private void handleUser() {System.out.println("Handling user");}private void handleGuest() {System.out.println("Handling guest");}
}

这个是大家比较常用的，通过不同的功能拆分成不同的函数。

7. 使用命令模式：将每个条件分支封装成一个命令对象，然后根据条件执行相应的命令。

优化前：

public class NoCommandExample {public void performAction(String action) {// 直接执行动作，没有使用命令模式if ("start".equals(action)) {System.out.println("Starting...");} else if ("stop".equals(action)) {System.out.println("Stopping...");}}
}

优化后：

public class CommandExample {interface Command {void execute();}public class StartCommand implements Command {public void execute() {System.out.println("Starting...");}}public class StopCommand implements Command {public void execute() {System.out.println("Stopping...");}}public void executeCommand(Command command) {command.execute();}
}

8. 使用状态模式：如果逻辑分支与状态有关，可以使用状态模式来管理状态转换。

优化前：

public class NoStateExample {public void handleAction(String state) {// 没有使用状态模式，直接在代码中处理逻辑if ("start".equals(state)) {System.out.println("Handling start");} else if ("stop".equals(state)) {System.out.println("Handling stop");}}
}

优化后：

public class StateExample {interface State {void handle();}public class StartState implements State {public void handle() {System.out.println("Handling start state");}}public class StopState implements State {public void handle() {System.out.println("Handling stop state");}}public class Context {private State state;public void setState(State state) {this.state = state;}public void request() {state.handle();}}
}

状态转换类似于我们在做一个简单的工单流转，每一步都是确定且可复用的场景。

9. 重构条件表达式：检查是否可以将复杂的条件表达式分解为更简单的部分。

优化前：

public class UnrefactoredConditionExample {public boolean isWeekend(int day) {// 没有重构的条件表达式，切套多、不好阅读if (day == 6 || (day == 7 && !isHoliday(day))) {return true;}return false;}private boolean isHoliday(int day) {// 法定的假日检查逻辑（法定节假日每年都在变）return false;}
}

优化后：

public class RefactoredConditionExample {public boolean isWeekend(int day) {return day == 6 || day == 7;}
}

简洁了很多

10. 使用断言：在某些情况下，使用断言来确保代码的预设条件被满足，避免复杂的条件判断。

优化前：

public class NoAssertExample {public void process(int value) {if (value <= 0) {throw new IllegalArgumentException("Value must be positive");}// 处理逻辑System.out.println("Processing value: " + value);}
}

优化后：

public class AssertExample {public void process(int value) {assert value > 0 : "Value must be positive";// 处理逻辑System.out.println("Processing value: " + value);}
}

多数编程中，断言被用在自动化测试用例。不过预设条件判断用起来也非常丝滑。

11. 使用异常处理：在某些情况下，使用异常处理来简化错误条件的处理。

优化前：

public class NoExceptionHandlingExample {public int divide(int dividend, int divisor) {if (divisor == 0) {// 没有使用异常处理，而是直接返回错误代码System.out.println("Cannot divide by zero");return -1;}return dividend / divisor;}
}

优化后：

public class ExceptionHandlingExample {public int divide(int dividend, int divisor) {try {return dividend / divisor;} catch (ArithmeticException e) {System.out.println("Cannot divide by zero");return -1;}}
}