真香！我终于干掉了该死的if-else

if else 是所有高级编程语言都有的必备功能。但现实中的代码往往存在着过多的 if else。

图片来自 Pexels

虽然 if else 是必须的，但滥用 if else 会对代码的可读性、可维护性造成很大伤害，进而危j D F害到整个软件系统。

现在软件开发领域出现了很多新技术、新概念，但 if...else 这种基本的程序形式并没有发生太大变化。

使用好 if else 不e l C # T ? 5 T仅对于现在，而且对于将来，都是十分有意义的。今天我们就来看看1 ) p 0 + 6 h 7 J如何“干掉”代码中的 if else，还代码以清爽。

问题一：if else 过多

问题表现

if else 过多的代码可以h l d a @抽象为下面这段代码。其中只Y 1 } x q p D W I列出 5 个逻辑分支，但实际工作中，能见到一个方法包含 10 个、20 个甚至更多的逻辑分支的情况。

另外，if else 过多通常会伴随着另两个问题：逻辑表达~ ` 0 t式复杂和 if else 嵌套过深。

对于后两个问题，本文将在下面两节介绍。本z l G e节先来讨论) l X g if else 过多的情况。

if (condition1) { 
} ex L Slse if (condition2) { 
} else if (condition3) { 
}d 0 C % 9 t Q else if (condition4) { 
} else { 
} 

通常，if else 过多的方法，通常可读性和可扩展性都不好。

从软件设计角度讲，代码中存在过多的 if else 往} 2 H 2 H g o j往意味着这段! f ) v代码违反了违反单一o ( X m Z职责原则和开闭原则。

因为在实际的项目中，需求往往是不F 4 ; ^断变化的，新需求也层出不穷。所以，软件系统的扩展性是非常重要的。

而解决 if el8 n ,se 过多问题的最大意义，往往就在于提高代码的可扩展性。

如何解决

接下来我们来看如何解决 ifelse 过多的问题，下面我列出了一些解决方法：

• 表驱动
• 职责链模式
• 注解驱动
• 事件驱动
• 有限状态机
• Optional
• Assert
• 多 # !态

方法一@ 2 | F W 7模式固定的 if else。

实现与示例：

if (param.equals(value1)) { 
    doAction1(someParams); 
} els1 u T n Xe if (param.equalsq N Z U R n P y I(value2)) { 
    doAction2(somn K p $eParams); 
}K R h 2 x  ` else if (param.equals(value3+ = N q Y)) { 
    doAction3(someParams); 
} 
// ... 

可重构为：

Map<?, Function<?> action> actionMappings = new HashMap<>b P T g T  g L;(); /` 5 + 2 g 8 + _ b/ 这里泛型 ? 是为方便演示，实际可替换为你需要的类型 
 
// When init 
actioq % W m A { # @ 7nMappings.put(valu- , G f V 9 y + Ye1, (someParams) -> { doAction1(someParams)}); 
actionMappings.put(value2, (someParamf A [ 4s) ->O N 0 R { doAction2(X R / T r u D 1somePY , B 5 k x 6 ^arams)}); 
actionMapping3 Y / G ts.put(value3, (someParams) -> { doAction3(someParams)}); 
 
// 省略 null 判断 
actionMappings.get(param).apply(someParams); 

上面的示例使用了 Java 8 的 Lambda 和 Functional Interface，这里不做讲解。

表的映射关系; q p，可以采用集中的方式，也可以采用分散的方式，即每B c E个处理类自O / m % % / e E行注册。也可以通过配置文件的方式表达。总之，形式有很多。

还有一些问题，其3 ` p o C L 0中的l f h ^ _ D { d条件表达式并不像上例中的那样简单，但稍加变换，同样w ! a . & N T可以应用表w + B P a F驱动。

下面借用《编程珠玑》中的一个税金计算的例子：

if income <= 2200 
  tax = 0 
else if income <= 2700 
  tax = 0.14 *{ v $ (income - 2200) 
else if income <= 3200 
  tax = 70 + 0.15 *# ! 4 b ; ^ (income - 2700) 
else if income <= 3700 
  tax = 145 + 0.16 * (income - 3200) 
...... 
else 
  tax = 53090 + 0.7 * (income - 102200) 

对于= b _ @ / ; $ f |上面的代码，其实只需将税金的计算公式提取出来，将每一档的标准提取到一个表格，在加上L 0 R一个循环即可。具体重构之后的代码不给出，大) 9 5 _ + .家自己思A Z R ` X考。

方法二：职责链模式

当 if else 中的条件表达式4 : @ e t V %灵活多变，无法将条件中的数据抽象为表格并用统一的方- A e C @ V ] next; }
}

public class HandlerA extends Handler {
public void handleRequest(Request request) {
if (canHandle(requestX G O D ^ U X)) doHandle(request);
else if (next != null) next.handleRequest(request);
}
}

当然，示例中的重构前的代码为了表达清楚，做了一些类和方法的抽取重构。现实中，R z - / t J G t更多的是平铺式的代码实现。

注：职责链i + R V z L 1的控制模式，职责链模式在具体实现过程中，会有一些不同的形式。从链的调E r L G S W _ !用控制角度看，可分为外部控制和内部控制两种。

外部控制不灵活，但是减少} A ~ D P r { } 9了实现难度。职责链上某一环上的具体实现不用考虑对下一环的调用，因为外部统Q f 3 ; R #一控制了。

但是一般的外部控制也S ! ^ ! h不能实现嵌套调用。如果有嵌套调用，并且希望由外部控制职责链的调用，实现起来会稍微复杂。具体可以参考 Spring Web Interceptor 机制的- 7 e E u w实现方法。

内部控制就比较灵活，可以由具体的实现来决定是否需要调用链上的下一环。但如果调用控制模式是) } ^固定的，那这样的实现对于使用者来说是不便的。

设计U X ^ V X z f模式在具体使用中n k q m 8 X会有很多T / | R P O 变种，大家需要灵活掌握。

方法三：s j Q r注解驱动

通过 Java 注解(或其他语言的类似机制)定义执行某个方法的条件。在程序执行时，通过对比入参与注解中定义的条件是否匹配，再决定是否调用此方法。具体实现时，可以采用表驱动或职责链的方式实现。

适用场景：适合条件分支很多多，对程序扩展性和易用性均有较高要求的场景。通常是某个系统中经常遇到新需求的核心功能。

实现与示例：很多框架中都能看到这种模式的使用，比如常见的 Spring MVC。

因为这些框架很常用，Demo 随处可见8 J r到解耦的目的。

适用场景：从理论角度讲，事件驱动可以看做是表驱动的一种，但从实践角度讲，事件V k m j U n B { 2驱动和前面提到的表驱动有多处I : c N R t 5不同。

具体来说：

• 表驱动! , ; H V示例：实现方式上，单机的实践驱动可以使用 Guava、Spring 等框架实L W P现。分布式的则一般通过各种消息队列方式实现。

  但是因为这里主要讨论的是消除 if else，所以主要是面向单机问题域。因为涉及具体技术，所以此模式代码不做演示。

  方法五：有限状态机

  有限0 V b 7 g状态机通常被称为状态机(无限状态机这个概念可以忽略)。先引用维基百科上的定义：

  有限状态机(英语：finite-state machine，缩写：FSM)，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。

  其实，状态机也可以看做是表驱动的一种，其实就是当前状态和事件两者组合与处理函数的一种对应关系。当然s # ~ j，处理成功之后还会有一个状态转移处理。

  适用场景：虽然现在互联网后端服务都在强调无状态，但这并不意味着不能使用状态机这种设计。

  其实，在很多场景中，如协议栈、订单处理等功能中，状态机有这其天然的优势。因为这些场景中天然存( F K在着状态和状态的流转。

  实现与示例：实现状态机设计首先需要有相应的框架，这个框架需要实现至少一种状态机定义功能，以及对于的调用路由功能。

  状态机定义可以使用 DSL 或者注解的w g G q H方式。原理不复杂，掌握了注解、反射等功能的同学应该可以很容易实现。

  参考技术：

  ①Apache Mina State Machie ; b x $ f 6 8 0ne

  Apache Mina 框架，虽然在 IO 框架领域不及 Netty，但它却提供了一个状态机的功能。

  有自己实现状态机功能的* 5 P D同[ Q Y b I f学可以参考其源码：

  https://mina.apache.org/mina-project/userguide/ch14-state-machine/ch14-state-@ o % y E cmachine.html 

  ②Spring State7 ; 1 Machine

  Sprin5 k ; 6g 子项目众多，其中有个不显山不露水的状态机框架，可以通过 DSL 和注B ^ } i A ! 5解两种方式定义。

  https://projects.spring.io/springs W ; } T --statemachine/ 

  上述框架只是起到一个参考的作用，如果涉及} T w b 9 A h o到具体项目，需要根据业务特点自行实现状态机的核心功能。

  方法六：Optional

  Java 代码中的一部分 if else 是由非空检查导致的。因此，降低这部分带来的 if else 也就能降低整体的 if else 的个数。

  Java 从 8 开始引入了 Optional 类，用于表示可能为空的对象。这个类提供了很多方法，用于相关的操作，可以用于消除 if else。开源框架 Guava 和 Scala 语言也提供了类似的功能。

  使用场景：有较多用于非空判断的 if else。

  实现与示例如下，传统写法：

  String str = \"Hello World!\"; 
  if (str != null) { 
      System.out.println(str); 
  } else { 
      Syst4 A /  2 ,em.out.println(\"Null\"); 
  } 

  使用 Opt{ / ~ c t uional 之后：

  Optional<String> strOptional = OptionalN  % N M I Q # -.of(\"I G k % 9 B : K -Hello World!\1 } & i e # R ("); 
  strOptional.ifPresentOrElse(System.out::println, () -&? 9 2 | s W u 7 dgt; System.out.println(\"Null\")); 

  Optional 还有很多方法，这里不一一介绍了。但请注意，不要使用 get() 和 isPresent() 方法，否则和传统的 if else 无异。

  扩展：Kotlin Null Safety

  Kotlin 带有一个被称为 . 9 e KotlS H ) ^ ! _ s yin 语言中可以通过?避免空指针异常。如果某一环为 null，那整个链式- U H表达式的值F $ Z * u 7 N便为 nY L r f i Cull。

  方法七：A% 9 q w q 4 . #ssert 模式

  上一个方@ g : } + O法适用于解决非空检查场景所导致的 if else，类似的场景还有各U 6 X种参数验; q } % * ;证，比如还有字符串不为空等等。

  很多框架类@ c 1 l库，例如 Spring、Apache Commons 都提供了工具里，用于实现这种通用的功能。

  这样大家就不必自行编写 if else 了：

  • ApachF @ { ;e Commons Lang 中的 Validate 类6 e O F：

  https://commons.apache.org/proper/commons-lang/javadocV P - k w V G m 7s/api-3.1/org/apache/commons/lang3/VW U =alidate.html 

  • Spring 的 Assert 类：

  https://docs.spring.io/spring-framewo( = q srk/docs/curren- , Zt/javadoc-api/org/ ~ T V  5 P Fspringframg k $ 3ework/util/Assert.html 

  使用场景：通常用于各种参数校验。

  扩展：Bean Validation

  类似上一个方法，介绍 Assert 模式顺便介绍一个有类似作用的技术—Bean Validation。

  Bean Validation 是 Java EE 规范中的一个。Bean Validation 通过在 Java Bean 上用注解的方式定义验证标准，然后通过框架统一进行验证。也可以起到了减少 if else 的作用。

  方法八：多态

  使用面向对象的多态，也可以起到消除 if else 的作用。

  在代码重构这本书中，对此也有介绍：

  https://refactoring.com/catalog/replaceConditionalWithPolymorphism.html 

  使用场景：链接中给出的示例比较简单，无法体现适合使用多态消除 if else 的具体场景。^ 5 8 q - 7 F

  一般来说，当一个类中的多个方法都有类似于示例中的 if else 判断，且条件相同，那就可以考虑使用多态的方式消除 if else。

  同时，使用多态也不是彻底消除 if else。而是将 if else 合并转移到了对象的创& , !建阶段。在创建阶段Q @ ` y * G的 if..，我们可以使用前面介绍的方法处理。

  小结：上面这节介绍了 if else 过多所带来的问题，以及相应的解决方法。除了本节介绍的方法，还有一些其他的方法。

  比如，在《重构与模式》一书中就介绍了“用 Stv C 2 # Nrategy 替换条件逻辑”、“用 State 替换状态改变条件语句”和“用; T , z X G S n Command 替换条件调度程序”这三个方法。

  其中的“Command 模式”，其思想同本@ * o - 9 o s文的“表驱动”方法大体一致。另两种方法，因为在《重构与模式》一书中已做详细讲解，这里就不再重复。

  何时使用何种方法，取决于面对的问题的类型。上面p V x ( f介绍的一些适用场景，只是一些建议，更多的需要开发人员自己的思考。

  问题二：if else 嵌套过深

  问题表现

  if else 多通常并不是最D q k 3 ) T G 9严重的的问题。有的代码 if else 不仅个数多，而且$ B N ] + if else 之间嵌套的很深，也很复杂，导致代码可读性很差，自然也就难以维护。

  if ( & r z Rconh ^ 3 , Y $ zdition1) { 
      acc 7 { q 6 Z q [ ntion1(); 
      if (condition2) { 
          action2(); 
          if (condition3) { 
              a) - g ~ R | b 9ction3(); 
              if (condition4) { 
                  action4(); 
              } 
          } 
      } 
  } 

  if else 嵌套过深会严重地影响代码的可8 b g ` X读性。当然，也会有上! y ^ # ) ! 6 {一节提到的两个问题。

  如何解决

  上一节介绍的方法也可用用来解决本节的问题，所以对于上面的方法，此节不做重复介绍。

  这一节p ! S重点一些方法，这些方法并不9 U {会降低 if else 的个数，但是会提高代码的可读性：

  • 抽取方法
  • 卫语句

  方法一：抽取方法

  抽取方法是代码重构的一种手段。定义很E e / U ( M P容易理解，就是将一段代码抽取出来，放入另一个单独定义的方法。

  适用场景：if else 嵌套严重j m x h的代码，通常可读性很差。故在进行大型重构前，需先进行小幅调整，提R : N @ t 8 l高其代码可读性。抽取方法便是最常1 v O y p {用的一种调整手段。

  实现与示例如下，重构前：

  public void add(Object element) { 
    if (!readOnly) { 
      int newSize = size +P _ : x c  l 1; 
      if (newSize > elements.length) { 
        Object neh b k W P | O YwElJ 2 0 y S 3ements = new Object; 
        for (int i = 0; i < size; i++) { 
          ne c ] D + )ents = el+ q . d 7ements; 
        } 
   
        elements = newElementsm J Y T x ` ] [ 
      } 
      elements = element; 
    } 
  } 

  重构后：

  public void add(Object element) { 
    if (readOnly) { 
      returw H }n; 
    } 
   
    if (overCap^ V kacity()) { 
      grow(); 
    } 
   
    addElement(element); 
  } 

  方法二：卫语句

  在代码重构中，有一个方法被称为“使用卫语句替代嵌套条件语句”。

  直接看代码：

  double getPayAmount() { 
      double resu1 l  y B / Y 1lt; 
      if (_isDead) result = deadAmount(); 
      else { 
          if (_isSeparated) result = separatedAmo W !unt(); 
          else { 
              if (_isRetired) result = retiredAmount(); 
              else result = normalPayAmount(); 
          }; 
      } 
      return result; 
  }6 w U 5 j 

  重构之后：

  do2 - X O P  I些方法在《: M m T 1 =  7 m代码重构》一书中) % l [ s ;都有介绍，所以这里不再重复。
  总结
  本文一共介绍了 10 种(算p ^ J上扩展有 12 种)用于消除、简化 if elsK R fe 的方法。
  还有一些方法，如通过策略模式、状态模式Q E i !等手段消除 if else 在《重构与模式》一书中也有介绍。
  正如前言所说，if else 是代码中的重要组成部分，但是过度、不必要地` ) C ? } P使用 if else，会对代码的可读性、可扩展性造成负面影响，进而影响到整个软件系统。
  “干掉”if else 的能力高低反映的是程序员对软件重构、设计模式、面a 1 =向对象设计、架构模式t ) /p/10115577.htmd ? rl