怎么避免在Java項目里大批量使用if-else

這篇文章主要講解了“怎么避免在Java項目里大批量使用if-else”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“怎么避免在Java項目里大批量使用if-else”吧！

避免大批量使用if-else

可能初學者都會忽略掉一點，其實if-else是一種面向過程的實現。

那么，如何避免在面向對象編程里大量使用if-else呢？

網絡上有很多解決思路，有工廠模式、策略模式、甚至是規則引擎（這個太重了吧）......

這些，都有一個共同的缺點，使用起來還是過于繁重了。雖說避免出現過多的if-else，但是，卻會增加很多額外的類，我總覺得，很不實用，只能當做某種模式的學習即可。

可以替換大量的if-else語句，且具備較好的可讀性與擴展性，同時能顯得輕量化，我比較推薦使用策略枚舉來消除if-else。

如何使用呢，下面先從一個業務案例開始說起下——

假如有這樣一個需求，需實現一周七天內分別知道要做事情的備忘功能，這里面就會涉及到一個流程判斷，你可能會立馬想到用if-else，那么，可能是會這樣實現——

//if-else形式判斷
  public String getToDo(String day){
      if("Monday".equals(day)){
          ......省略復雜語句
         return "今天上英語課";
     }else if("Tuesday".equals(day)){
          .....省略復雜語句
          return "今天上語文課";
     }else if("Wednesday".equals(day)){
         ......省略復雜語句
         return "今天上數學課";
      }else if("Thursday".equals(day)){
         ......省略復雜語句
        return "今天上音樂課";
    }else if("sunday".equals(day)){
         ......省略復雜語句
        return "今天上編程課";
     }else{
         此處省略10086行......
     }
 }

這種代碼，在業務邏輯里，少量還好，若是幾百個判斷呢，可能整塊業務邏輯里都是滿屏if-else,既不優雅也顯得很少冗余。

這時，就可以考慮使用策略枚舉形式來替換這堆面向過程的if-else實現了。

首先，先定義一個getToDo()調用方法，假如傳進的是“星期一”，即參數"Monday"。

//策略枚舉判斷
public String getToDo(String day){
    CheckDay checkDay=new CheckDay();
    return checkDay.day(DayEnum.valueOf(day));
}

在getToDo()方法里，通過DayEnum.valueOf("Monday")可獲取到一個DayEnum枚舉元素，這里得到的是Monday。

接下來，執行checkDay.day(DayEnum.valueOf("Monday"))，會進入到day（）方法中，這里，通過dayEnum.toDo()做了一個策略匹配時。注意一點，DayEnum.valueOf("Monday")得到的是枚舉中的Monday，這樣，實質上就是執行了Monday.toDo()，也就是說，會執行Monday里的toDo()——

public class CheckDay {
    public String day( DayEnum dayEnum) {
        return dayEnum.toDo();
    }
}

上面的執行過程為什么會是這樣子呢？只有進入到DayEnum枚舉當中，才知道是怎么回事了——(話外音：我第一次接觸策略模式時，猛地一驚，原來枚舉還可以這樣玩)

public enum DayEnum {
    Monday {
        @Override
        public String toDo() {
            ......省略復雜語句
            return "今天上英語課";
        }
    },
    Tuesday {
        @Override
        public String toDo() {
            ......省略復雜語句
            return "今天上語文課";
        }
    },
    Wednesday {
        @Override
        public String toDo() {
            ......省略復雜語句
            return "今天上數學課";
        }
    },
    Thursday {
        @Override
        public String toDo() {
            ......省略復雜語句
            return "今天上音樂課";
        }
    };
    public abstract String toDo();
}

在DayEnum枚舉屬性當中，定義了一個實現了toDo()抽象方法——

public abstract String toDo();

在每個枚舉元素當中，都重寫了該toDo()抽象方法。這樣，當傳參DayEnum.valueOf("Monday")流轉到dayEnum.toDo()時，實質上是去DayEnum枚舉里找到對應Monday定義的枚舉元素，然后執行其內部重寫的toDo()方法。用if-esle形式表示，就類似"Monday".equals(day)匹配為true時，可得到其內部東西。

總結一下，策略枚舉就是枚舉當中使用了策略模式，所謂的策略模式，即給你一把鑰匙，按照某種約定的方式，可以立馬被指引找到可以打開的門。例如，我給你的鑰匙叫“Monday”，那么，就可以通過約定方式dayEnum.toDo()，立馬找到枚舉里的Monday大門，然后進到門里，去做想做的事toDo()，其中，每扇門后的房間都有不同的功能，但它們都有一個相同抽象功能——toDo()，即各房間共同地方都是可以用來做一些事情的功能，但具體可以什么事情，就各有不同了。在本文的案例里，每扇大門里的toDo()，根據不同策略模式可得到不同字符串返回，例如，"今天上英語課"、"今天上語文課"，等等。

可見，把流程判斷抽取到策略枚舉當中，還可以把一堆判斷解耦出來，避免在業務代碼邏輯里呈現一大片密密麻麻冗余的if-else。

這里，會出現一種情況，即，假如有多個重復共同樣功能的判斷話，例如，在if-else里，是這樣——

public String getToDoByIfElse(String day){
    if("Monday".equals(day)||"Tuesday".equals(day)||"Wednesday".equals(day)){
        ......省略復雜語句
        return "今天上英語課";
    }else if("Thursday".equals(day)){
        ......
    }
}

那么，在策略枚舉下應該如何使用從而避免代碼冗余呢？

可以參考一下以下思路，設置一個內部策略枚舉，將有相同功能的外部引用指向同一個內部枚舉元素，這樣即可實現調用重復功能了——

public enum DayEnum {
    //指向內部枚舉的同一個屬性即可執行相同重復功能
    Monday("星期一", Type.ENGLISH),
    Tuesday("星期二", Type.ENGLISH),
    Wednesday("星期三", Type.ENGLISH),
    
    Thursday("星期四", Type.CHINESE);
    private final Type type;
    private final String day;
    DayEnum(String day, Type type) {
        this.day = day;
        this.type = type;
    }
    String toDo() {
        return type.toDo();
    }
    /**
     * 內部策略枚舉
     */
    private enum Type {
        ENGLISH {
            @Override
            public String toDo() {
                ......省略復雜語句
                return "今天上英語課";
            }
        },
        CHINESE {
            @Override
            public String toDo() {
                ......省略復雜語句
                return "今天上語文課";
            }
        };
        public abstract String toDo();
    }
}

若要擴展其判斷流程，只需要直接在枚舉增加一個屬性和內部toDo（實現），就可以增加新的判斷流程了，而外部，仍舊用同一個入口dayEnum.toDo()即可。

可能，會有這樣一個疑問：為什么在枚舉里定義一個抽象方法，會在各個枚舉元素里實現呢？

這功能就類似子類繼承父類的做法了。DayEnum類似一個父類，DayEnum枚舉里的元素就相當是其子類。當父類里定義了抽象方法toDo（），其繼承的子類就會默認實現toDo()方法，這樣，就會出現枚舉里可以這樣的寫法：

private enum Type {
        ENGLISH {
            @Override
            public String toDo() {
                return "今天上英語課";
            }
        }；
        public abstract String toDo();
    }

我很喜歡在大批量if-else里使用策略枚舉來消除替換，總而言之，使用策略枚舉可以很靈活處理各種復雜判斷，且可讀性與擴展性都比較好，它更像是函數式編程，即傳進一個參數，就可以得到對應模式下返回的數值。

若Java里業務邏輯中大批量使用if-else，則是面向過程了，因為業務邏輯里的if-else是從上往下一個if接一個if判斷下去的，在各個if上打個斷點，debug下去，就明白它其實是面向過程的。

由此可知，若項目里有大量的if-else話，著實是一件很影響性能的事情，雖然這點性能可忽略不計，但有更好的取代方案，不是更好嗎？

感謝各位的閱讀，以上就是“怎么避免在Java項目里大批量使用if-else”的內容了，經過本文的學習后，相信大家對怎么避免在Java項目里大批量使用if-else這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！