Java | if-else代码优化方案

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

优化前 ：

1if(condition){
2    //doSomething
3}else{
4     return
5}

优化后：

1if（!condition）{
2    return
3 }
4//doSomething

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

优化前：

1int price ;
2if(condition){
3    price = 80;
4}else{
5    price = 100;
6}

优化后：

1int price = condition?80:100;

在某些时候，使⽤枚举也可以优化if-else逻辑分⽀，按个⼈理解，它也可以看作⼀种表驱动⽅法。

优化前：

1String OrderStatusDes;
2if(orderStatus==0){
3    OrderStatusDes="订单未⽀付";
4}else if(OrderStatus==1){
5    OrderStatusDes="订单已⽀付";
6}else if(OrderStatus==2){
7    OrderStatusDes="已发货";
8}
9...

优化后：

 1//先定义⼀个枚举：
 2String OrderStatusDes;
 3if(orderStatus==0){
 4    OrderStatusDes="订单未⽀付";
 5}else if(OrderStatus==1){
 6    OrderStatusDes="订单已⽀付";
 7}else if(OrderStatus==2){
 8 OrderStatusDes="已发货";
 9 }
10 ...

1//有了枚举之后，以上if-else逻辑分⽀，可以优化为⼀⾏代码：
2String OrderStatusDes = OrderStatusEnum.0f(orderStatus).getDesc();

如果有⼀系列条件返回⼀样的结果，可以将它们合并为⼀个条件表达式，让逻辑更加清晰。

优化前：

 1double getVipDiscount() {
 2if(age<18){
 3    return 0.8;
 4}
 5if("深圳".equals(city)){
 6    return 0.8;
 7}
 8if(isStudent){
 9    return 0.8;
10}
11//do somethig
12}

优化后：

1double getVipDiscount(){
2if(age<18|| "深圳".equals(city)||isStudent){
3    return 0.8;
4}
5//doSomthing
6}

有时候if-else比较多，是因为非空判断导致的，这时候你可以使⽤java8的Optional进行优化。

优化前：

1String str = "jay@huaxiao";
2if(str != null) {
3    System.out.println(str);
4} else{
5    System.out.println("Null");
6}

优化后：

1Optional<String> strOptional = Optional.of("jay@huaxiao");
2strOptional.ifPresentOrElse(System.out::println, () -> System.out.println("Null"));

表驱动法，⼜称之为表驱动、表驱动方法。表驱动⽅法是⼀种使你可以在表中查找信息，而不必用很多的逻辑语句（if或case）来把它们找出来的⽅法。以下的demo，把map抽象成表，在map中查找信息，而省去不必要的逻辑语句。

优化前：

1if(param.equals(value1)) {
2    doAction1(someParams);
3} else if(param.equals(value2)) {
4    doAction2(someParams);
5} elseif(param.equals(value3)) {
6    doAction3(someParams);
7}
8// ...

优化后：

1// 这里泛型 ? 是为方便演示，实际可替换为你需要的类型
2Map<?, Function<?> action> actionMappings = newHashMap<>();

1// 初始化
2actionMappings.put(value1, (someParams) -> { doAction1(someParams)});
3actionMappings.put(value2, (someParams) -> { doAction2(someParams)});
4actionMappings.put(value3, (someParams) -> { doAction3(someParams)});

1// 省略多余逻辑语句
2actionMappings.get(param).apply(someParams);

优化前：

1public double getAdjustedCapital(){
2    if(_capital <= 0.0){
3        return 0.0;
4    }
5    if(_intRate > 0&& _duration >0){
6       return (_income / _duration) *ADJ_FACTOR;
7    }
8      return 0.0;
9}

优化后：

1public double getAdjustedCapital(){
2    if(_capital <= 0.0){
3        return 0.0;
4    }
5    if(_intRate <= 0|| _duration <= 0){
6        return 0.0;
7    }
8    return (_income / _duration) *ADJ_FACTOR;
9}

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

假设需求为，根据不同勋章类型，处理相对应的勋章服务，优化前有以下代码：

1public double getAdjustedCapital(){
2    if(_capital <= 0.0){
3        return 0.0;
4    }
5    if(_intRate <= 0|| _duration <= 0){
6        return 0.0;
7    }
8    return (_income / _duration) *ADJ_FACTOR;
9}

⾸先，我们把每个条件逻辑代码块，抽象成⼀个公共的接口，可以得到以下代码：

1//勋章接口
2public interface IMedalService{
3    void showMedal();
4    String getMedalType();
5}

我们根据每个逻辑条件，定义相对应的策略实现类，可得以下代码：

 1//守护勋章策略实现类
 2public class GuardMedalServiceImpl implements IMedalService{
 3    @Override
 4    public void showMedal() {
 5        System.out.println("展⽰守护勋章");
 6    }
 7    @Override
 8    public String getMedalType() {
 9    return"guard";
10    }
11}
12//嘉宾勋章策略实现类
13public class GuestMedalServiceImpl implements IMedalService{
14    @Override
15    publicvoid showMedal() {
16        System.out.println("嘉宾勋章");
17    }
18    @Override
19    publicString getMedalType() {
20        return "guest";
21    }
22}
23//VIP勋章策略实现类
24public class VipMedalServiceImpl implements IMedalService{
25    @Override
26    publicvoid showMedal() {
27        System.out.println("会员勋章");
28    }
29    @Override
30    publicString getMedalType() {
31       return"vip";
32    }
33}

接下来，我们再定义策略⼯⼚类，⽤来管理这些勋章实现策略类，如下：

 1//勋章服务⼯产类
 2public class MedalServicesFactory{
 3    private static finalMap<String, IMedalService> map = newHashMap<>();
 4    static{
 5        map.put("guard", newGuardMedalServiceImpl());
 6        map.put("vip", newVipMedalServiceImpl());
 7        map.put("guest", newGuestMedalServiceImpl());
 8    }
 9    public static IMedalService getMedalService(String medalType) {
10        return map.get(medalType);
11    }
12}

使用了策略+工厂模式之后，代码变得简洁多了，如下：

1public class Test{
2    public static void main(String[] args) {
3        String medalType = "guest";
4        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
5        medalService.showMedal();
6}
7}