JDK1.5引入了新的型別——列舉。在 Java 中它雖然算個“小”功能，卻給我的開發帶來了“大”方便。

用法一：常量

在JDK1.5 之前，我們定義常量都是： public static final.... 。現在好了，有了列舉，可以把相關的常量分組到一個列舉型別裡，而且列舉提供了比常量更多的方法。

1. public enum Color {  
2.   RED, GREEN, BLANK, YELLOW  
3. }  

用法二：switch

JDK1.6之前的switch語句只支援int,char,enum型別，使用列舉，能讓我們的程式碼可讀性更強。

1. enum Signal {  
2.     GREEN, YELLOW, RED  
3. }  
4. public class TrafficLight {  
5.     Signal color = Signal.RED;  
6.     public void change() {  
7.         switch (color) {  
8.         case RED:  
9.             color = Signal.GREEN;  
10.             break;  
11.         case YELLOW:  
12.             color = Signal.RED;  
13.             break;  
14.         case GREEN:  
15.             color = Signal.YELLOW;  
16.             break;  
17.         }  
18.     }  
19. }  

用法三：向列舉中新增新方法

如果打算自定義自己的方法，那麼必須在enum例項序列的最後新增一個分號。而且 Java 要求必須先定義 enum例項。

1. public enum Color {  
2.     RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("黃色"
   , 4);  
3.     // 成員變數  
4.     private String name;  
5.     private int index;  
6.     // 構造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     // 普通方法  
12.     public static String getName(int index) {  
13.         for (Color c : Color.values()) {  
14.             if (c.getIndex() == index) {  
15.                 return c.name;  
16.             }  
17.         }  
18.         return null;  
19.     }  
20.     // get set 方法  
21.     public String getName() {  
22.         return name;  
23.     }  
24.     public void setName(String name) {  
25.         this.name = name;  
26.     }  
27.     public int getIndex() {  
28.         return index;  
29.     }  
30.     public void setIndex(int index) {  
31.         this.index = index;  
32.     }  
33. }  

用法四：覆蓋列舉的方法

下面給出一個toString()方法覆蓋的例子。

1. public enum Color {  
2.     RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("黃色", 4);  
3.     // 成員變數  
4.     private String name;  
5.     private int index;  
6.     // 構造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     //覆蓋方法  
12.     @Override  
13.     public String toString() {  
14.         return this.index+"_"+this.name;  
15.     }  
16. }  

用法五：實現介面

所有的列舉都繼承自java.lang.Enum類。由於Java 不支援多繼承，所以列舉物件不能再繼承其他類。

1. public interface Behaviour {  
2.     void print();  
3.     String getInfo();  
4. }  
5. public enum Color implements Behaviour{  
6.     RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("黃色", 4);  
7.     // 成員變數  
8.     private String name;  
9.     private int index;  
10.     // 構造方法  
11.     private Color(String name, int index) {  
12.         this.name = name;  
13.         this.index = index;  
14.     }  
15. //介面方法  
16.     @Override  
17.     public String getInfo() {  
18.         return this.name;  
19.     }  
20.     //介面方法  
21.     @Override  
22.     public void print() {  
23.         System.out.println(this.index+":"+this.name);  
24.     }  
25. }  

用法六：使用介面組織列舉

1. public interface Food {  
2.     enum Coffee implements Food{  
3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
4.     }  
5.     enum Dessert implements Food{  
6.         FRUIT, CAKE, GELATO  
7.     }  
8. }  

用法七：關於列舉集合的使用

java.util.EnumSet和java.util.EnumMap是兩個列舉集合。EnumSet保證集合中的元素不重複；EnumMap中的key是enum型別，而value則可以是任意型別。關於這個兩個集合的使用就不在這裡贅述，可以參考JDK文件。

關於列舉的實現細節和原理請參考：

參考資料：《ThinkingInJava》第四版

範例：

publicclass TestEnum {
    /*最普通的列舉*/publicenum ColorSelect {
        red, green, yellow, blue;    
    }

    /* 列舉也可以象一般的類一樣新增方法和屬性,你可以為它新增靜態和非靜態的屬性或方法,這一切都象你在一般的類中做的那樣. */publicenum Season {
        // 列舉列表必須寫在最前面，否則編譯出錯        winter, spring, summer, fall;

        privatefinalstatic String location ="Phoenix";        

        publicstatic Season getBest() {
            if (location.equals("Phoenix"))
                return winter;
            elsereturn summer;
        }
    }
    /*還可以有構造方法*/publicenum Temp {
        /*通過括號賦值,而且必須有帶參構造器和一屬性跟方法，否則編譯出錯
         * 賦值必須是都賦值或都不賦值，不能一部分賦值一部分不賦值
         * 如果不賦值則不能寫構造器，賦值編譯也出錯*/
        absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);
        
        privatefinalint value;
        publicint getValue() {
            return value;
        }
        //構造器預設也只能是private, 從而保證建構函式只能在內部使用        Temp(int value) {
            this.value = value;
        }
    }

    publicstaticvoid main(String[] args) {
        /*
         * 列舉型別是一種型別，用於定義變數，以限制變數的賦值 賦值時通過"列舉名.值"來取得相關列舉中的值
         */
        ColorSelect m = ColorSelect.blue;
        switch (m) {
        /*注意:列舉重寫了ToString(),說以列舉變數的值是不帶字首的
          *所以為blue而非ColorSelect.blue
          */

case red:
            System.out.println("color is red");
            break;
        case green:
            System.out.println("color is green");
            break;
        case yellow:
            System.out.println("color is yellow");
            break;
        case blue:
            System.out.println("color is blue");
            break;
        }
        System.out.println("遍歷ColorSelect中的值");
        /*通過values()獲得列舉值的陣列*/for (ColorSelect c : ColorSelect.values()) {
            System.out.println(c);
        }　 

　　 System.out.println("列舉ColorSelect中的值有："+ColorSelect.values().length+"個");

 　　/*ordinal()返回列舉值在列舉中的索引位置，從0開始*/　　System.out.println(ColorSelect.red.ordinal());//0
　　System.out.println(ColorSelect.green.ordinal());//1
　　System.out.println(ColorSelect.yellow.ordinal());//2
　　System.out.println(ColorSelect.blue.ordinal());//3

　　/*列舉預設實現了java.lang.Comparable介面*/ 
　　System.out.println(ColorSelect.red.compareTo(ColorSelect.green));

　　System.out.println(Season.getBest());
        
        for(Temp t:Temp.values()){
            /*通過getValue()取得相關列舉的值*/
            System.out.println(t+"的值是"+t.getValue());
        }

    }
}