首先給出文章的結(jié)論：

• 枚舉是類類型
• 每個枚舉常量都是所屬枚舉類的對象
• 枚舉類在加載完成后，無法再進行實例化操作
• 枚舉是線程安全的

java 中的枚舉在實現(xiàn)上非常簡單，以下就是一個枚舉的例子：

public enum FruitEnum {
    APPLE
}

但是如果反編譯 FruitEnum.class，會發(fā)現(xiàn)編譯器在背后默默的做了大量的工作，以下是反編譯結(jié)果：

public final class FruitEnum extends Enum {
    public  static final FruitEnum APPLE;
    private static final FruitEnum $VALUES[];

    private FruitEnum(String s, int i) {
        super(s, i);
    }
  
    public static FruitEnum[] values() {
        return (FruitEnum[])$VALUES.clone();
    }

    public static FruitEnum valueOf(String name) {
        return (FruitEnum)Enum.valueOf(FruitEnum, name);
    }
  
    static {
        APPLE = new FruitEnum("APPLE", 0);
        $VALUES = (new FruitEnum[] {
            APPLE
        });
    }
}

下面根據(jù)反編譯結(jié)果說明枚舉的幾個特性。

• 枚舉的實際類型

public final class FruitEnum extends Enum

說明枚舉是類，并且是用 final 修飾的類，意味著枚舉不能再被繼承擴展。而我們聲明枚舉類時使用的 enum 只是一個關(guān)鍵字。

其次，所有的枚舉都繼承了一個基類 Enum ，該基類為枚舉提供了一些通用方法。

• 枚舉的構(gòu)造函數(shù)

在 FruitEnum 中，我們并沒有定義構(gòu)造函數(shù)，但在反編譯的代碼中，我們發(fā)現(xiàn)編譯器自動幫我們添加了以下私有構(gòu)造函數(shù)：

private FruitEnum(String s, int i) {
    super(s, i);
}

該私有構(gòu)造函數(shù)只是簡單調(diào)用了父類 Enum 的構(gòu)造函數(shù)：

protected Enum(String name, int ordinal) {
    this.name = name;       // 枚舉常量的名稱
    this.ordinal = ordinal; // 枚舉常量在枚舉類的位置，從0開始
}

實際上，編譯器只允許私有的枚舉類構(gòu)造函數(shù)，并且顯示定義的枚舉構(gòu)造函數(shù)經(jīng)編譯器后，都會被添加 name 和 ordinal 2個參數(shù)，用以調(diào)用父類 Enum 的構(gòu)造函數(shù)。

• 枚舉常量

再看反編譯后的 FruitEnum 中的成員變量：

public  static final FruitEnum APPLE;
private static final FruitEnum $VALUES[];

其中 FruitEnum APPLE 對應我們定義的枚舉常量 APPLE，而 FruitEnum $VALUES[] 則是容納所有枚舉常量的數(shù)組。

這兩個變量初始化操作如下：

static {
    APPLE = new FruitEnum("APPLE", 0);
    $VALUES = (new FruitEnum[] { APPLE });
}

可知，每個枚舉常量都是定義它的類的對象，各枚舉對象都是用 public static final 修飾的，這也是枚舉對象被稱為枚舉常量的原因。

其次，FruitEnum APPLE 和 FruitEnum $VALUES[] 都是在靜態(tài)代碼塊中進行初始化，因此在 JVM 記載完成枚舉類后，各枚舉常量都已被

創(chuàng)建完畢。由于枚舉類中只允許出現(xiàn)私有構(gòu)造函數(shù)，固無法再實例化新的枚舉對象。

• 枚舉類實例化

無法通過構(gòu)造函數(shù)這種一般手段實例化枚舉類，那么通過反射呢？

先嘗試以下形式：

Class<FruitEnum> fruitEnumClazz = FruitEnum.class;
FruitEnum fruitDemo1 = fruitEnumClazz.newInstance();

拋出了以下錯誤：

因為 Class.newInstance 內(nèi)部是通過目標Class的 無參構(gòu)造函數(shù) 創(chuàng)建實例的，而上文已經(jīng)說了 FruitEnum 的實際構(gòu)造函數(shù)是：

private FruitEnum(String s, int i) {
    super(s, i);
}

固會找不到對應的構(gòu)造函數(shù)，拋出異常。

換種反射方式，先獲取正確的構(gòu)造函數(shù)：

// 獲取 FruitEnum 的構(gòu)造函數(shù)
Constructor<FruitEnum> fruitEnumConstructor = fruitEnumClazz.getDeclaredConstructor(String.class, int.class);
// 獲取訪問權(quán)限
fruitEnumConstructor.setAccessible(true);
// 實例化
FruitEnum fruitDemo2 = fruitEnumConstructor.newInstance();

成功獲取了 FruitEnum 的構(gòu)造函數(shù)，然而還是拋出了異常：

在 JVM 層面禁止了通過反射構(gòu)造枚舉實例的行為。

然而除了反射外，還可以通過 Object.clone() 方法克隆一個已存在的對象。但是這種方式也是不行的，看 Enum 類中的 clone() 方法：

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

Enum 類重寫了 Obejct 的 clone()方法，只要嘗試通過 clone() 方法構(gòu)造枚舉對象，都會拋出異常，并且該方法被設置為不能再重寫。

• 單例

從編譯器、JVM，再到 java 內(nèi)部設計，層層把關(guān)，封死了實例化枚舉類的這一企圖。因此有一種作法是通過枚舉的形式實現(xiàn)單例，下面給個示例：

public class EnumSingleton{
    private EnumSingleton() {
      
    }
  
    public static EnumSingleton getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    
    private static enum Singleton {
        INSTANCE;
        
        private EnumSingleton singleton;
        
        // JVM 保證了此方法絕對只調(diào)用一次
        private Singleton(){
            singleton = new EnumSingleton();
        }
        
        public EnumSingleton getInstance(){
            return singleton;
        }
    }
}

• 線程安全

  枚舉常量都是 static 類型的，在枚舉類加載完成后，會進行枚舉常量的初始化，之后枚舉類無法再實例化和修改。java 的類加載、初始化過程是線程安全的，因此創(chuàng)建一個 enum 是線程安全的。