一、前言

代码中如果 if-else 比较多，会降低代码的可读性。维护起来也比较麻烦，因此在代码中尽量减少 if-else 的出现频率，或者使用一些常规的手段来替代，增强代码的可读性。

二、优化方案1 —— 提前 return，去除不必要的 else 代码块

如果if-else代码块包含return语句，可以考虑通过提前return，把多余else干掉，使代码更加优雅。

优化前：

if(condition) {
	//doSomething
} else {
    return;
}

优化后：

if(!condition){
	return;
}

//doSomething

三、优化方案2 —— 使用三目运算符

使用条件三目运算符可以简化某些if-else,使代码更加简洁，更具有可读性。

优化前：

int price;
if(condition) {
	price = 80;
} else {
	price = 100;
}

优化后：

int price = condition ? 80 : 100;

四、优化方案3 —— 使用枚举

在某些时候，使用枚举也可以优化if-else逻辑分支。

优化前：

String orderStatusDesc = "";

if (orderStatus == 0) {
	orderStatusDesc = "订单未支付";
} else if (orderStatus == 1) {
	orderStatusDesc = "订单已支付";
} else if(orderStatus == 2) {
	orderStatusDesc = "已发货";
}

优化前：

// 枚举类
public enum OrderStatusEnum {

    UN_PAID(0, "订单未支付"),
    PAIDED(1, "已支付"),
    SENDED(2, "已发货");

    private int status;

    private String desc;

    OrderStatusEnum(int status, String desc) {
        this.status = status;
        this.desc = desc;
    }

    public int getStatus() {
        return status;
    }

    public String getDesc() {
        return desc;
    }

    OrderStatusEnum of(int orderStatus) {
        for(OrderStatusEnum temp : OrderStatusEnum.values()) {
            if (temp.getStatus() == orderStatus) {
                return temp;
            }
        }
        return null;
    }
}

有了枚举之后，以上if-else逻辑分支，可以优化为一行代码

String orderStatusDesc = OrderStatusEnum.of(orderStatus).getDesc();

五、优化方案4 —— 优化逻辑结构，正常的业务逻辑走主干代码

将条件反转使异常情况先退出，让正常流程维持在主干流程，可以让代码结构更加清晰。

优化前：

    public int test01(int income) {
        double rate = 0.13;
        if (income <= 0) {
            return 0;
        }
        if (income > 0 && income <=2000) {
            return (int) (income * rate);
        }
        return 0;
    }

优化后：

    public int test02(int income) {
        double rate = 0.13;
        if (income <= 0) {
            return 0;
        }
        if (income > 2000) {
            return income;
        }
        return (int) (income * rate);
    }

六、优化方案5 —— 策略模式 + 工厂方法替代 if else

假设需求：根据不同的支付类型，处理相应的支付逻辑。

优化前：

String payType = "wechat";
if ("wechat".equals(payType)) {
	wechatPayAction();
} else if ("ali".equals(payType)) {
	aliPayAction();
} else if ("eBank".equals(payType)) {
	eBankPayAction();
}

优化后：

1、首先把每个条件逻辑代码块，抽象成一个公共接口：

public interface IPayService {
    
    void payAction();
    
    String getPayType();

}

2、根据每个逻辑条件，定义相应的策略实现类：

微信支付策略实现类

public class WechatPayServiceImpl implements IPayService{
    @Override
    public void payAction() {
        System.out.println("wechat支付逻辑...");
    }

    @Override
    public String getPayType() {
        return "wechat";
    }
}

支付宝支付策略实现类

public class AliPayServiceImpl implements IPayService{
    @Override
    public void payAction() {
        System.out.println("支付宝支付逻辑...");
    }

    @Override
    public String getPayType() {
        return "ali";
    }
}

网银支付策略实现类

public class EbankPayServiceImpl implements IPayService{
    @Override
    public void payAction() {
        System.out.println("网银支付逻辑...");
    }

    @Override
    public String getPayType() {
        return "ebank";
    }
}

3、定义策略工厂类，用来管理这些支付实现策略类：

import java.util.HashMap;
import java.util.Map;

public class PayServicesFactory {

    private static final Map<String, IPayService> map = new HashMap<>();
    
    static {
        map.put("ali", new AliPayServiceImpl());
        map.put("wechat", new WechatPayServiceImpl());
        map.put("ebank", new EbankPayServiceImpl());
    }
    
    public static IPayService getPayService (String payType) {
        return map.get(payType);
    }

}

4、使用策略+工厂模式后，测试类：

public class Test {

    public static void main(String[] args) {
        String payType = "wechat";
        IPayService payService = PayServicesFactory.getPayService(payType);
        payService.payAction();
    }

}