枚舉的用法
每個枚舉變量其實都是枚舉類的一個實例。

枚舉與單例
各種模式的單例模式，包括枚舉實現的單例

//懶漢模式 class SingletonA {private static SingletonA instance = new SingletonA();//保證不能通過new SingletonB的方式創建對象private SingletonA(){}public static SingletonA getInstance() {return instance;} }//保證效率的懶加載 class SingletonB {private static SingletonB instance;private SingletonB(){}public static SingletonB getInstance() {if(instance == null) {synchronized (SingletonB.class) {if (instance == null) {instance = new SingletonB();}}}return instance;} }//內部類懶漢模式 class SingletonC {private SingletonC(){}private static class SingletonHolder {private static final SingletonC instance = new SingletonC();}public SingletonC getInstance() {return SingletonHolder.instance;} }//內部枚舉類懶加載模式 class SingletonD {private SingletonD(){}private enum EnumSingleton {instance;//因為枚舉變量是static final的，所以如果不是定義時聲明，那只能在構造方法中實例化，并且有且只能實例化一次。//所以保證了resource對象的單例性。private SingletonD singletonD;private EnumSingleton() {singletonD = new SingletonD();}}public SingletonD getInstance() {return EnumSingleton.instance.singletonD;} }

枚舉如何比較
可以用equals()，也可以用==，推薦使用==
enum的equals()方法實現如下：

public final boolean equals(Object other) {return this==other;}

可以看出，也是調用的==實現的。
官方文檔說明如下：

JLS 8.9 Enums 一個枚舉類型除了定義的那些枚舉常量外沒有其他實例了。 試圖明確地說明一種枚舉類型是會導致編譯期異常。 在枚舉中final clone方法確保枚舉常量從不會被克隆，而且序列化機制會確保從不會因為反序列化而創造復制的實例。 枚舉類型的反射實例化也是被禁止的。 總之，以上內容確保了除了定義的枚舉常量之外，沒有枚舉類型實例。

另外，==和equals()的不同如下：

== 不會拋出 NullPointerException enum Color { BLACK, WHITE };Color nothing = null; if (nothing == Color.BLACK); // runs fine if (nothing.equals(Color.BLACK)); // throws NullPointerException== 在編譯期檢測類型兼容性 enum Color { BLACK, WHITE }; enum Chiral { LEFT, RIGHT };if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine if (Color.BLACK == Chiral.LEFT); // DOESN'T COMPILE!!! Incompatible types!

總而言之，在枚舉比較上使用 == ， 因為： 1. 能正常工作 2. 更快 3. 編譯期是安全的 4. 運行時也是安全的

switch 對枚舉的支持
枚舉 switchcase 標簽必須為枚舉常量的非限定名稱
用法如下：

//定義枚舉 public enum Color {RED,GREEN,YELLOW; }//使用枚舉 public void compare(Color color) {switch (color) {case RED:break;case YELLOW:break; default:break;}}

枚舉的線程安全性問題
枚舉的序列化如何實現
枚舉是線程安全的，描述如下：

1：枚舉的實現方式

//定義枚舉 public enum t {SPRING,SUMMER,AUTUMN,WINTER; } //反編譯枚舉類 public final class T extends Enum {private T(String s, int i){super(s, i);}public static T[] values(){T at[];int i;T at1[];System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.length], 0, i);return at1;}public static T valueOf(String s){return (T)Enum.valueOf(demo/T, s);}public static final T SPRING;public static final T SUMMER;public static final T AUTUMN;public static final T WINTER;private static final T ENUM$VALUES[];static{SPRING = new T("SPRING", 0);SUMMER = new T("SUMMER", 1);AUTUMN = new T("AUTUMN", 2);WINTER = new T("WINTER", 3);ENUM$VALUES = (new T[] {SPRING, SUMMER, AUTUMN, WINTER});} }

通過反編譯后代碼我們可以看到，public final class T extends Enum，說明，該類是繼承了Enum類的，同時final關鍵字告訴我們，這個類也是不能被繼承的。
并且方法與屬性都是static的，而static類型的屬性會在類被加載之后被初始化。當一個Java類第一次被真正使用到的時候靜態資源被初始化、Java類的加載和初始化過程都是線程安全的。所以，創建一個enum類型是線程安全的。

2：枚舉的序列化
JavaDoc中的描述：

序列化的時候Java僅僅是將枚舉對象的name屬性輸出到結果中， 反序列化的時候則是通過java.lang.Enum的valueOf方法來根據名字查找枚舉對象。 同時，編譯器是不允許任何對這種序列化機制的定制的， 因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。

我們看一下這個valueOf方法：

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 const " + enumType +"." + name); }

從代碼中可以看到，代碼會嘗試從調用enumType這個Class對象的enumConstantDirectory()方法返回的map中獲取名字為name的枚舉對象，如果不存在就會拋出異常。再進一步跟到enumConstantDirectory()方法，就會發現到最后會以反射的方式調用enumType這個類型的values()靜態方法，也就是上面我們看到的編譯器為我們創建的那個方法，然后用返回結果填充enumType這個Class對象中的enumConstantDirectory屬性。

所以，JVM對序列化有保證。
此段描述來自于：http://blog.jobbole.com/94074/

總結

以上是生活随笔為你收集整理的Java修炼之路——基础篇——枚举的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。