想起剛開始接觸JAVA面向?qū)ο缶幊虝r，若遇到大量流程判斷語句，幾乎滿屏都是if-else語句，多得讓自己都忘了哪里是頭，哪里是尾，但是，縱然滿屏是if-else，但彼時也沒有覺得多別扭。等到編程能力漸漸提升之后，再回過頭去看曾經(jīng)寫過的滿屏if-else時，腦海里只有一個畫面，全都是翔.....

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

那么，如何避免在面向?qū)ο缶幊汤锎罅渴褂胕f-else呢？

網(wǎng)絡(luò)上有很多解決思路，有工廠模式、策略模式、甚至是規(guī)則引擎（這個太重了吧）......

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

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

如何使用呢，下面先從一個業(yè)務(wù)案例開始說起下——

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

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

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

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

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

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

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

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

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

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

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

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

public abstract String toDo();

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

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

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

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

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

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

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

public enum DayEnum {
    //指向內(nèi)部枚舉的同一個屬性即可執(zhí)行相同重復功能
    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();
    }
    /**
     * 內(nèi)部策略枚舉
     */
    private enum Type {
        ENGLISH {
            @Override
            public String toDo() {
                ......省略復雜語句
                return "今天上英語課";
            }
        },
        CHINESE {
            @Override
            public String toDo() {
                ......省略復雜語句
                return "今天上語文課";
            }
        };
        public abstract String toDo();
    }
}

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

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

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

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

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

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

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

總結(jié)

本篇文章就到這里了，希望能給您帶來幫助，也希望你能夠多多關(guān)注腳本之家的更多內(nèi)容！

最新評論