走進 JDK 之 Enum

什麼是枚舉

什麼是枚舉？說實話，在我這些年的開發生涯中，用過枚舉的次數大概兩隻手都可以數的過來。當然你不能說枚舉一無是處，只能說是我對 Java 理解的還不夠深刻，在可以使用枚舉的時候並沒有去使用。

假設我有兩個孩子（其實不用假設），每到週末他們都不知道去上什麼輔導班。於是我就寫了一個簡單的程序來告訴他們，僞代碼如下：

public final static int DAVID = 0;
public final static int MARRY = 1;

public void order(int who){
    switch (who){
        case DAVID:
            System.out.println("大衛，去練武術！");
            break;
        case MARRY:
            System.out.println("瑪麗，去練跳舞!");
            break;
         default:
            System.out.println("今天休息");
    }
}

然後我告訴 David 你輸入 0，告訴 Marry 你輸入 1，就可以了。不久之後，輔導班老師就指點問候我了，您家的兩個孩子呢？這個氣的我呀，立馬回家看了看日誌，兩個孩子除了 0 和 1，其他數字都輸齊了。

由此可見，這樣直接使用 int 常量無法限定用戶的輸入，你讓它輸 0 或 1，它偏偏輸個 45678。從代碼可讀性來說，參數是個 int 值，並不是那麼直觀的就可以看出來應該輸入什麼。無奈之下，我只得掏出 《Java 編程思想》，來治治這兩個熊孩子。下面是我優化的程序：

public enum Child { DAVID, MARY }

public  void order(Child who) {
    switch (who) {
        case DAVID:
            System.out.println("大衛，去練武術！");
            break;
        case MARY:
            System.out.println("瑪麗，去練跳舞!");
            break;
        default:
            System.out.println("今天休息");
    }
}

實際上已經可以刪除 default 了，因爲參數是枚舉類 Child，輸入範圍已經被限定爲我定義的枚舉，輸入其他值將無法通過編譯。兩個熊孩子終於可以愉快的去上課了。

枚舉是 Java 1.5 中新增的引用類型，指由一組固定的常量組成合法值的類型，其實上面的例子並不那麼適合枚舉，例如一年四季，一週七天這樣的，更加適合枚舉。相比使用 int 常量來定義，枚舉具有類型安全和可讀性良好的優勢。《Effective Java》中也鼓勵 用 enum 代替 int 常量。

除此之外，還可以給枚舉添加字段和方法，例如，我想給每個孩子加上姓名，可以這麼做：

public enum Child {

    DAVID("David"), MARY("Marry");

    private String name;

    Child(String name){
        this.name=name;
    }
    
    public static void main(String[] args){
        for (Child child:Child.values()){
            System.out.println(child.ordinal()+" "+child.name);
        }
    }
}

注意，枚舉的定義只能放在第一行，如果你把 DAVID("David"), MARY("Marry"); 放在其他位置，是無法通過編譯的。另外別忘了，最後一個枚舉常量後面要加分號。

values() 會枚舉出 Child 中定義的所有枚舉常量。打印結果如下：

0 David
1 Marry

是不是比之前的 int 常量那種方式強大多了。

源碼解析

Enum

走進 JDK 系列，那必然是少不了源碼解析的。

類定義

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {}

Enum 是一個抽象類，我們自己定義的枚舉類都繼承了 Enum。實現了 Comparable 接口，重寫了 compare 的邏輯。實現了 Serializable 接口，可以序列化。但是枚舉對序列化作了一定的限制，在序列化的時候僅僅是將枚舉對象的 name 屬性輸出到結果中，反序列化的時候則是通過 Enum.valueOf() 方法來查找枚舉對象。同時，編譯器是不允許任何對這種序列化機制的定製的，因此禁用了 writeObject 、readObject 、readObjectNoData 、writeReplace 和 readResolve 等方法。因此，用枚舉來實現單例模式的話，是反序列化安全的，因爲即使反序列化也不會生成新的對象。

字段

private final String name; // 枚舉實例的名稱，就是枚舉聲明中的名稱
private final int ordinal; // 在枚舉聲明中的次序，從 0 開始

枚舉類就只有這兩個字段。name 就是枚舉聲明的名字，比如 DAVID 的 name 就是 DAVID。ordinal 就是聲明中的次序，之所以在 switch 中可以使用枚舉，就是因爲編譯器會自動調用枚舉的 ordinal() 方法。

構造函數

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

受保護的，你不能調用枚舉類的構造函數。

方法

public final String name() {
    return name; // 返回 name
}

public final int ordinal() {
    return ordinal; // 返回 ordinal
}

public String toString() {
    return name; // 可以重寫使得枚舉類返回一個用戶友好的名字，默認返回 name
}

public final boolean equals(Object other) {
    return this==other; // 枚舉的 equals 和 == 是等價的
}

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException(); // 枚舉不支持 clone，單例
}

public final int compareTo(E o) {
    Enum<?> other = (Enum<?>)o;
    Enum<E> self = this;
    if (self.getClass() != other.getClass() && // optimization
        self.getDeclaringClass() != other.getDeclaringClass())
        throw new ClassCastException();
    return self.ordinal - other.ordinal; // 實際上是比較 ordinal
}

// 根據指定的枚舉類型和名稱返回枚舉實例，在反序列化中會使用
public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
    T result = enumType.enumConstantDirectory().get(name);
    if (result != null)
        return result;
    if (name == null)
        throw new NullPointerException("Name is null");
    throw new IllegalArgumentException(
        "No enum constant " + enumType.getCanonicalName() + "." + name);
}

還記得之前使用過的 values() 方法嗎，用來遍歷枚舉的。找遍了 Enum.java 也沒有看到這個方法，既然父類中沒有這個方法，那麼一定是在子類中聲明的了。下面我們來驗證一下。

Enum 子類

我們是怎麼定義枚舉的，

public enum Child {
    DAVID("David"), MARY("Marry");
    private String name;
    Child(String name){
        this.name=name;
    }
}

並沒有顯示的去繼承 Enum，而是使用了 enum 關鍵字，雖然沒有使用 class 關鍵字，但其實它還是一個類，只是編譯器幫我們做了中間步驟。之前有說過，知其然不知其所以然的時候，javap 是你的好幫手。這次我們不 javap 了，畢竟字節碼可讀性不是那麼的好。我們使用 jad 反編譯 Child.class 文件，得到結果如下:

// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Child.java

package enums;

public final class Child extends Enum {

    public static Child[] values() {
        return (Child[])$VALUES.clone();
    }

    public static Child valueOf(String s) {
        return (Child)Enum.valueOf(enums/Child, s);
    }

    private Child(String s, int i, String s1) {
        super(s, i);
        name = s1;
    }

    public static final Child DAVID;
    public static final Child MARY;
    private String name;
    private static final Child $VALUES[];

    static {
        DAVID = new Child("DAVID", 0, "David");
        MARY = new Child("MARY", 1, "Marry");
        $VALUES = (new Child[] {
            DAVID, MARY
        });
    }
}

看到這個東西，你就應該全明白了。說起來叫枚舉，其實就是普通的類，只是我們只需要使用 enum 關鍵字，編譯器就會幫我們做好一切。枚舉中聲明的變量都是 static final 的，且在 static 代碼塊中進行初始化，並存入對象數組 $VALUES。所以枚舉實例的創建默認是線程安全的。除此之外，編譯器還自動生成了 values() 方法，返回 $VALUES 數組的克隆。

說到這裏，你應該對枚舉的原理很清楚了。枚舉的種種特性都特別契合單例模式，天生的線程安全和反序列化安全，這都是其他單例模式所不具備的。但是在我所見過的代碼中，真正使用枚舉去做單例的好像少之又少。具體的原因有待考究。

真的要使用枚舉嗎？

站在 Android 開發者的角度，實際上官方是不建議我們使用枚舉的。

枚舉佔用的空間通常是靜態常量的兩倍。你應該嚴格避免在 Android 中使用枚舉。

其實我並不是完全贊同。MVP 多了那麼多接口和類，我們應該使用嗎？在如今的手機內存下，如果你的應用發生了 OOM，我想枚舉應該不是罪魁禍首吧。只要不過度使用，站在增強代碼可讀性，保證類型安全的角度，用枚舉代替靜態常量肯定是個好選擇。當然如果你說你要追求極致的性能，那倒不必使用枚舉了。

文章首發微信公衆號： 秉心說 ， 專注 Java 、 Android 原創知識分享，LeetCode 題解，歡迎關注！