在我们平时的开发过程中，经常可能会出现大量If else的场景，代码显的很臃肿，非常不优雅。那我们又没有办法处理呢？

针对大量的if嵌套让代码的复杂性增高而且难以维护。本文将介绍多种解决方案。

下面模拟业务逻辑，根据传入的条件作出不同的处理方式。

拿一个计算器类当做案例，有加减乘除四种方法，输出结果和四种操作有关。

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;
随着条件越来越多，复杂性也增高，也越来越难以维护。
 
1、工厂类我们将操作进行抽象给出一个操作接口
 
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;
然后通过操作工厂提供操作
 
public class OperatorFactory {
    static Map<String, Operation> operationMap = new HashMap<>();
    static {
        operationMap.put("add", new Addition());
        operationMap.put("divide", new Division());
        // more operators
    public static Optional<Operation> getOperation(String operator) {
        return Optional.ofNullable(operationMap.get(operator));
public int calculateUsingFactory(int a, int b, String operator) {
    Operation targetOperation = OperatorFactory
      .getOperation(operator)
      .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
    return targetOperation.apply(a, b);
新增操作只需要维护操作工厂的operationMap即可。
 
2、使用枚举
 
在枚举中定义操作，如下：
 
public enum Operator {
    ADD, MULTIPLY, SUBTRACT, DIVIDE
然而不同的操作对应的逻辑不一样，我们编写抽象方法
 
ADD {
    @Override
    public int apply(int a, int b) {
        return a + b;
// other operators
public abstract int apply(int a, int b);
调用时直接传入枚举值
 
public int calculate(int a, int b, Operator operator) {
    return operator.apply(a, b);
@Test
public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
    assertEquals(7, result);
3、命令模式
 
定义命令接口。
 
public interface Command {
    Integer execute();
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类，加入执行命令的方法。
 
public int calculate(Command command) {
    return command.execute();
@Test
public void whenCalculateUsingCommand_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(new AddCommand(3, 7));
    assertEquals(10, result);
4、规则引擎
 
定义规则接口
 
public interface Rule {
    boolean evaluate(Expression expression);
    Result getResult();
实现规则引擎
 
public class RuleEngine {
    private static List<Rule> 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();
定义表达式
 
public class Expression {
    private Integer x;
    private Integer y;
    private Operator operator;
定义加法规则
 
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;
给规则引擎传入表达式来调用
 
@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());
总结虽然说常见的代码中if...else不可避免，但滥用 if...else 会对代码的可读性、可维护性造成很大伤害。因此，使用好 if...else，让代码清爽对于你的项目长远考虑有十分重要的意义。
 
 
英文原文：https://www.baeldung.com/java-replace-if-statements
 
 
其他参考资料：
 
 
策略设计模式：http://www.runoob.com/design-pattern/strategy-pattern.html
 
 
命令设计模式：http://www.runoob.com/design-pattern/command-pattern.html
 
推荐阅读：
 
Java8中遍历Map的常用四种方式
 
推荐一些MySQL优化技巧，效率提升不止十倍！
 
44个Java代码优化手段，保证性能溜溜的！
 
扫码关注公众号，发送关键词获取相关资料：
 
 
发“Springboot”领取电商项目实战源码;
 
 
发“SpringCloud”领取学习实战资料;
 
 
                    在我们平时的开发过程中，经常可能会出现大量If else的场景，代码显的很臃肿，非常不优雅。那我们又没有办法处理呢？针对大量的if嵌套让代码的复杂性增高而且难以维护。本文将介绍多种解决方案。案例下面模拟业务逻辑，根据传入的条件作出不同的处理方式。拿一个计算器类当做案例，有加减乘除四种方法，输出结果和四种操作有关。public int calculate(int a, in...
				
大家在开发过程中，经常会用到if...else语句，尤其针对那些业务分支较多的情况下，if...else显得非常臃肿，大大影响代码的可读性，并且增加了维护的成本，一些大公司代码规范比较严格，单个类或者单个方法也有圈复杂度的最大限制。那么，针对以上，来和大家探讨下if...else的替代方案。假设我们现在要做一个计算器，实现加减乘除的功能：
头疼的if...else
public static int calculate(String operator, int a, int b) {
				
参考博客： Java中的大量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 ("...
				
If-Else已成为事实上的代码分支解决方案，这确实是有道理的。这是向所有有抱负的开发人员讲授的第一件事。不幸的是，许多开发人员从来没有前进到更合适的开发实践中去。
有些人的口头禅是：If-Else是一把锤子，一切都是钉子。
在这里，我将向你展示一些技巧和模式，这些技巧和模式将终结这种可怕的做法。
每个示例的难度都会增加。
1、 完全不必要的Else块
这也许是那些初级开发人员最负罪的之一。下面的示例很好地说明了当您被认为If-Else很棒时会发生什么。
Simple if-else
只需删除else
				
Java使用策略模式替换掉 if else
我们的代码中常常大量的使用 if else ，如果条件在不断的增加，我们就需要继续在后面增加if else，代码就会越来越臃肿，可读性差，后期非常不好维护,下面给大家分享一下策略模式的使用。
什么是策略模式
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。
下面就以发送消息为例，在不同的业务场景我们需要给客户发送不同的消息。
定义抽象策略
				
if...else是Java中的分支结构之一，用于根据条件执行不同的代码块。if语句用于判断条件是否成立，如果成立则执行if后面的代码块，否则执行else后面的代码块。例如：
if (条件) {
    // 如果条件成立，执行这里的代码块
} else {
    // 如果条件不成立，执行这里的代码块
if...else语句可以嵌套使用，形成多重分支结构，例如：
if (条件1) {
    // 如果条件1成立，执行这里的代码块
} else if (条件2) {
    // 如果条件2成立，执行这里的代码块
} else {
    // 如果条件1和条件2都不成立，执行这里的代码块
if...else语句是Java编程中非常常用的语句之一，可以帮助我们根据不同的条件执行不同的代码，实现更加灵活的程序逻辑。