如何优化代码中大量的if/else

古城微笑少年丶 2024-04-18 23:53 65阅读 0赞

> 日常我们在写代码或者读代码时，有时会发现代码中存在大量的if/else。甚至会嵌套多层，这样会大大降低代码的可读性，使得代码维护起来费时费力。那么有什么方案可以优化代码中大量的if/else呢，下面就给大家简单的介绍几种方法。

#### 1. 提前return ####

在写判断条件时，选择取反判断，这样的话代码在逻辑表达上会更清晰，看下面代码：

if (condition) {
     // do something
    } else {
      return xxx;
    }

其实像上面这种代码，我们可以选择先判断`!condition`，这样就不用再写else了。

if (!condition) {
      return xxx;
    } 
    // do something

#### 2. 使用策略模式 ####

有时我们会遇到，同一件事分多种情况，每种情况需要不同的处理方法的场景。

我们可以根据参数不同，来选择相应的处理方式。例如在计算器中的加减乘除。

一般的实现：

if (strategy.equals("add")) {
      // 加法
    } else if (strategy.equals("subtraction")) {
      // 减法
    } else if (strategy.equals("multiplication")) {
      // 乘法
    } else if (strategy.equals("division")) {
      // 除法
    }

看上面代码，有4种策略，有两种优化方案。

#### 2.1 多态 ####

1.策略接口

interface Strategy {
        void run() throws Exception;
    }

2. 接口实现

class AddStrategy implements Strategy {
        @Override
        public void run() throws Exception {
            // 加法执行逻辑 打印代码供测试使用
            System.out.println("加法执行逻辑");
        }
    }
    
    class SubtractionStrategy implements Strategy {
        @Override
        public void run() throws Exception {
            // 减法执行逻辑
        }
    }
    
    class MultiplicationStrategy implements Strategy {
        @Override
        public void run() throws Exception {
            // 除法执行逻辑
        }
    }
    
    class DivisionStrategy implements Strategy {
        @Override
        public void run() throws Exception {
            // 乘法执行逻辑
        }
    }

3.具体策略对象存可以放在一个Map中。

import java.util.HashMap;
    import java.util.Map;
    
    public class StrategyMap {
        private static Map<String, Strategy> strategyMap = new HashMap<>();
    
        static {
            strategyMap.put("add", new AddStrategy());
            strategyMap.put("subtraction", new SubtractionStrategy());
            strategyMap.put("multiplication", new MultiplicationStrategy());
            strategyMap.put("division", new DivisionStrategy());    
        }
    
        public Strategy get(String param) {
            return strategyMap.get(param);
        }
    }

4.进行优化后实现，这样通过传递的参数就可以采用具体的策略了

public class testStrategy {
        public static void main(String[] args) throws Exception {
            //传递参数获取指定策略实现
            Strategy strategy=StrategyMap.get("add");
            strategy.run();
        }
    }

**注：**但是采用上面这种优化方案有一个弊端，为了能够快速拿到对应的策略实现，需要map对象来保存策略，当添加一个新策略的时候，还需要手动添加到map中，容易遗漏。

#### 2.2 枚举 ####

发现很多同学不知道在枚举中可以定义方法，这里定义一个表示状态的枚举，另外可以实现一个run方法。

public enum Status {
        NEW(0) {
          @Override
          void run() {
            //do something
          }
        },
        RUNNABLE(1) {
          @Override
           void run() {
             //do something  
          }
        };
    
        public int statusCode;
    
        abstract void run();
    
        Status(int statusCode){
            this.statusCode = statusCode;
        }
    }

重新定义策略枚举。

public enum Strategy {
        ADD {
          @Override
          void run() {
            // 加法执行逻辑 打印代码供测试使用
            System.out.println("加法执行逻辑");
          }
        },
        SUBTRACTION {
          @Override
           void run() {
             //do something  
          }
        },
    
        MULTIPLICATION {
          @Override
           void run() {
             //do something  
          }
        },
    
        DIVISION {
          @Override
           void run() {
             //do something  
          }
        };
        abstract void run();
    }

通过枚举优化之后的代码如下：

public class testStrategy {
        public static void main(String[] args) throws Exception {
            //传递参数获取指定策略实现
            Strategy strategy = Strategy.valueOf("ADD");
            strategy.run();
        }
    }

#### 3. 学会使用 Optional ####

Optional主要用于非空判断，是jdk8新特性，用起来真的非常方便，尤其是对于非空校验。

使用之前：

if (user == null) {
        //do action 1
    } else {
        //do action2
    }

如果登录用户为空，执行action1，否则执行action 2，使用Optional优化之后，让非空校验更加优雅，间接的减少if操作。

Optional<User> userOptional = Optional.ofNullable(user);
    userOptional.map(action1).orElse(action2);

#### 4. 利用数组 ####

来自google解释，这是一种编程模式，叫做表驱动法，本质是从表里查询信息来代替逻辑语句，比如有这么一个场景，通过月份来获取当月的天数，仅作为案例演示，数据并不严谨。

一般的实现：

int getDays(int month){
        if (month == 1)  return 31;
        if (month == 2)  return 29;
        if (month == 3)  return 31;
        if (month == 4)  return 30;
        if (month == 5)  return 31;
        if (month == 6)  return 30;
        if (month == 7)  return 31;
        if (month == 8)  return 31;
        if (month == 9)  return 30;
        if (month == 10)  return 31;
        if (month == 11)  return 30;
        if (month == 12)  return 31;
    }

优化后的代码：

int monthDays[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int getDays(int month){
        return monthDays[--month];
    }

#### 结束总结： ####

if else作为每种编程语言都不可或缺的条件语句，在编程时会大量的用到。一般建议嵌套不要超过三层，如果一段代码存在过多的if else嵌套，代码的可读性就会急速下降，后期维护难度也大大提高。