前期迭代懒得优化，来一个需求，加一个if，久而久之，就串成了一座金字塔。

if(true){
    if(true){
        if(true){
            if(true){
                if(true){

                }
            }
        }
    }
}

当代码已经复杂到难以维护的程度之后，只能狠下心重构优化。那，有什么方案可以优雅的优化掉这些多余的if/else?

提前return

这是判断条件取反的做法，代码在逻辑表达上会更清晰，我们先看下面代码：

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

其实，每次看到上面这种代码，我都心里抓痒，完全可以先判断!condition，干掉else。

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

策略模式

有这么一种场景，根据不同的参数走不同的逻辑，其实这种场景很常见。
最一般的实现：

if (strategy.equals("fast")) {
    // 快速执行
} else if (strategy.equals("normal")) {
    // 正常执行
} else if (strategy.equals("smooth")) {
    // 平滑执行
} else if (strategy.equals("slow")) {
    // 慢慢执行
}

我们观察上面代码，有4种策略，有两种优化方案。

多态

interface Strategy {
    void run() throws Exception;
}

class FastStrategy implements Strategy {
    @Override
    public void run() throws Exception {
        // 快速执行逻辑
        System.out.println("快速执行逻辑");
    }
}

class NormalStrategy implements Strategy {
    @Override
    public void run() throws Exception {
        // 正常执行逻辑
        System.out.println("正常执行逻辑");
    }
}

class SmoothStrategy implements Strategy {
    @Override
    public void run() throws Exception {
        // 平滑执行逻辑
        System.out.println("平滑执行逻辑");
    }
}

class SlowStrategy implements Strategy {
    @Override
    public void run() throws Exception {
        // 慢速执行逻辑
        System.out.println("慢速执行逻辑");
    }
}

我们将具体策略对象存放在一个Map中，优化后的实现

// 初始化map，将策略放入
private static HashMap<String,Strategy > map = new HashMap<String,Strategy >(){
    {
        put("FastStrategy",new FastStrategy());
        put("NormalStrategy",new NormalStrategy());
        put("SmoothStrategy",new SmoothStrategy());
        put("SlowStrategy",new SlowStrategy());
    }
};

// 构建方法，通过传入的key触发对应的策略
public static void testStrategy(String param) throws Exception {
    Strategy strategy  = map.get(param);
    strategy.run();
}

// 测试
public static void main(String[] args) throws Exception {
    testStrategy("FastStrategy");
}

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

枚举

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

定义策略枚举

package com.studymongo.test;
/**
* 策略枚举类
* @author wangcp
* @date 2021/02/20 16:42
*/

public enum StrategyEnum {
    FAST {
        @Override
        void run() {
            //do something
            System.out.println("FAST");
        }
    },
    NORMAL {
        @Override
        void run() {
            //do something
        }
    },

    SMOOTH {
        @Override
        void run() {
            //do something
        }
    },

    SLOW {
        @Override
        void run() {
            //do something
        }
    };
    abstract void run();
}

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

StrategyEnum strategyEnum = StrategyEnum.valueOf("FAST");
strategyEnum.run();

使用 Optional

Optional主要用于非空判断，由于是Java8新特性，所以使用的不是特别多，但是用起来是真的爽。

使用之前

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);

数组小技巧

经查阅来自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的层数，然后拆出一堆方法导致代码可读性更差…