定義

關鍵字enum可以將一組具名的值的有限集合建立為一種新的型別，而這些具名的值可以作為常規的程式元件使用。

入門

//定義一個普通列舉
enum Shrubbery {GROUND, CRAWLING, HANGING}

public class EnumClass {
    public static void main(String[] args) {
        for (Shrubbery s : Shrubbery.values()) {
            //輸出列舉的名稱和索引下標
            System.out.println(s + " ordinal: " + s.ordinal());
            //重寫了compareTo方法，輸入當前列舉下標與指定列舉下標的差值
            System.out.println(s.compareTo(Shrubbery.CRAWLING));
            //equals方法與==符號作用相等
            System.out.println(s.equals(Shrubbery.CRAWLING));
            System.out.println(s == Shrubbery.CRAWLING);
            //所屬的類
            System.out.println(s.getDeclaringClass());
            //輸出例項宣告的名字
            System.out.println(s.name());
            System.out.println("-------------");
        }

        //通過String陣列，獲取列舉例項,前提是該String必須在列舉中，否則報錯
        for (String s : "HANGING CRAWLING GROUND".split(" ")) {
            Shrubbery shrubbery = Enum.valueOf(Shrubbery.class, s);
            System.out.println(shrubbery + "ordinal: " + shrubbery.ordinal());
        }
    }
}
 

建構函式建立列舉

需要注意的一個地方：在列舉中定義方法和屬性，必須在列舉例項聲明後才能定義。否則編譯器報錯。

public enum OzWitch {
    //通過私有建構函式，構建列舉
    WEST("this is WEST"),
    NORTH("this is NORTH"),
    EAST("this is EAST"),
    SOUTH("this is SOUTH");
    
    //重點：只能在列舉例項之後定義方法和屬性
    private String description;
    //私有建構函式
    private OzWitch(String description){
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public static void main(String[] args) {
        for (OzWitch o : OzWitch.values()){
            //迴圈遍歷，並獲取description欄位資訊
            System.out.println(o+":"+o.getDescription());
        }
    }
}
 

switch中使用

列舉具備整數值的次序，且可通過ordinal()方法取得次序，所以可以在switch中使用列舉

//定義列舉
enum Signal{GREEN,YELLOW,RED}

public class SwitchEnum {
    //預設的列舉值
    Signal color = Signal.RED;

    public void change(){
        //通過列舉就可以直接在列舉中使用，而不用呼叫ordinal()方法
        //顯然編譯器已經做了優化
        switch (color){
            case RED:color = Signal.GREEN;break;
            case GREEN:color = Signal.YELLOW;break;
            case YELLOW:color = Signal.RED;break;
        }
    }

    @Override
    public String toString() {
        return "SwitchEnum{" +
                "color=" + color +
                '}';
    }

    public static void main(String[] args) {
        SwitchEnum s = new SwitchEnum();
        for (int i = 0; i < 7; i++) {
            System.out.println(s);
            s.change();
        }
    }
}
 

隨機讀取

enum Activity{A,B,C,D,E,F,G}
public class EnumRandom{
    //定義隨機物件
    private static Random random = new Random(47);
    // <T extends Enum<T>> 代表列舉物件
    public static <T extends Enum<T>> T random(Class<T> ec){
        return random(ec.getEnumConstants());
    }
    //過載random方法，目的是為了不破壞Enum的操作
    public static <T> T random(T[] values){
        return values[random.nextInt(values.length)];
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            //直接傳入列舉類，就可以實現隨機讀取了
            System.out.println(random(Activity.class));
        }
    }
}

設計模式

單例模式

public class Singleton {
    //使用列舉，構建單例模式
    private Singleton() {
    }


    private enum SingletonEnum {
        //申明唯一一個單利列舉
        singletonEnum;
        //申請單利物件
        private Singleton singleton;

        SingletonEnum(){
            //在列舉的建構函式中，獲取物件例項
            singleton = new Singleton();
        }

        //返回單例物件
        public Singleton getInstance(){
            return singleton;
        }
    }


    public static Singleton getInstance(){
        //直接返回列舉的getInstance方法，即可獲取單例物件
        return SingletonEnum.singletonEnum.getInstance();
    }
}

策略模式

public class Strategy {
    public enum ROLE{
        //在列舉中實現抽象函式
        ADMIN{
            @Override
            public void speak(){
                System.out.println("我是管理員");
            }
        },
        USER{
            @Override
            public void speak(){
                System.out.println("我是使用者");
            }
        },
        VIP{
            @Override
            public void speak(){
                System.out.println("我是vip");
            }
        };

        //宣告一個抽象方法，目的是為了使角色有一個統一的行為
        public abstract void speak();
    }


    public static void main(String[] args) {
        //直接使用即可
        ROLE.ADMIN.speak();
        ROLE.USER.speak();
        ROLE.VIP.speak();
    }
}

總結

列舉在實際開發中運用的場景不多。在我所參與的專案中，列舉其實是作為業務表中的狀態欄位對映，通過使用列舉，不再使用硬編碼。比如，狀態欄位state，有三種狀態 0：未完成；2：完成中；2：已完成，判斷狀態時，不再用0/1/2去判斷，而使用列舉定義的key和value去判斷。這樣在程式碼的可讀行和維護性上，提高了很多。

public enum DemoEum {
    END(0, "未完成"),
    DOING(1,"完成中")
    FINISH(2,"已完成")
    ;
    private Integer key;
    private String value;

    public Integer getKey() {
        return key;
    }

    public void setKey(Integer key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    DemoEum (Integer key, String value) {
        this.key = key;
        this.value = value;
    }

未使用列舉時

    ....
    if(state == 0){//未完成。。。。
    }else if(state == 1){//完成中。。。。
    }
    ....

使用列舉

 ....
    if(state == DemoEum.END.getKey()){//未完成。。。。
    }else if(state == DemoEum.DOING.getKey()){//完成中。。。。
    }
    ....