听了张老师的枚举。还是感觉有点模糊。不是很明白。希望各位前辈帮帮忙。给一些文字版或者带代码的解析。

枚举，。你可以理解为数字，
  public enum mj {
   a,b=5,c
}
a = 0
b = 5
c =6

枚举里面的元素都是它本身这个类的对象；
而且构造方法是私有的，为了不让再创建出其它的对象；
只能用它本身里面指定的元素（也是他自身的对象）；

我百度,希望对你有帮助.           

1.   枚举是Java5（Tiger）中新增的一种类型，这个类型是为了弥补Java不支持枚举类型的遗憾。
   
2. 
   
3.     首先，给大家枚举一个总的印象。枚举是一种特殊的 “类”，不是一种接口，它的枚举值都是一个枚举类型的实例。下面我们来具体讲讲枚举。
   
4. 
   
5. 一、创建一个枚举
   
6. package com.mercy.tiger;
   
7.   public enum EnumOne {
   
8.    One,TWO,Three
   
9. }
   
10. 
    
11.    很简单，有点像创建一个类，事实上他就是“类”，特殊的“类”。看看第三行，这里是什么东西啊？其实枚举就是一些“常数”，这些常数在这个集合中。这里就是One，TWO，Three就在EnumOne集合中。这里值得说明的是，这三个都是EnumOne的实例，这就是枚举的特殊性。
    
12. 怎么来用它呢？
    
13. 
    
14.    public static void main(String[] args){
    
15.      EnumOne one=EnumOne.One;
    
16.      System.out.println(one);
    
17.      // result : One
    
18.     }
    
19. 
    
20. 二、内置枚举
    
21. 我们来写一个内置（写在一个类的内部）的枚举
    
22. public class  InnerEnum {
    
23. private enum  ALPHABEAT{A,B,C}
    
24.     public static void main(String[] args) {
    
25.        ALPHABEAT  a=ALPHABEAT.A;        
    
26.    
    
27.      }
    
28. }
    
29. 我们在这里可以看出ALPHABEAT是个静态枚举类型，所以在它前面加个static也没有关系.
    
30. 三、迭代枚举
    
31.    我们在这之前，我们应该讲讲枚举的 “类”的特性，但是他又不是类（矛盾？）。 我们要迭代枚举的话，我们要用到这个静态方法values(),返回一个对应的枚举数组。
    
32. 
    
33.     这个方法是JVM内部生成的，给所有的枚举类型的方法，所以枚举很特殊，有“类”性。
    
34. 
    
35. public class Test{
    
36.   private enum  ALPHABEAT{A,B,C}
    
37.   public static void   main(String[] args) {
    
38.    for(ALPHABEAT a : ALPHABEAT.values())
    
39.     {
    
40.         System.out.println(a);
    
41.     }
    
42.   }
    
43. }
    
44. 其结果是：
    
45. A
    
46. B
    
47. C
    
48. 
    
49. 
    
50. 四、高级内容
    
51.     恐怕在我们日常中使用了很多枚举，比如把枚举作为条件，比如在switch语句中 使用。 前面可能提示性地说到，枚举值是常量，所以可以作为swtich中的case条件。再用前面的例子：
    
52. ALPHABEAT a=ALPHABEAT.A;
    
53. 
    
54. switch(a) {
    
55.   case ALPHABEAT.A:
    
56. case ALPHABEAT.B:
    
57. case ALPHABEAT.C:
    
58. }
    
59. 
    
60. 很抱歉，这个例子是错的。你会问错在哪里啦？我告诉你的枚举引用是不能作为case条件的。所以我们只能这么做：
    
61. 
    
62. switch(a){
    
63.   //caseALPHABEAT.A:
    
64.   //caseALPHABEAT.B:
    
65.   //caseALPHABEAT.C:
    
66.   case A:
    
67.   case B:
    
68.   case C:
    
69. }
    
70. 
    
71. 好了，我们在说说枚举的“类”性...
    
72. 1.添加方法：
    
73. public enum EnumWithMethod {
    
74. Enum1,Enum2,Enum3;
    
75.   public String getName() {
    
76.     return this.getName();
    
77.   }
    
78. }
    
79. 
    
80. 发现没有，还有this引用哦！你说它有类性吗？还有令你更吃惊的东西： 我们可以定义main方法，不行试试：
    
81. 
    
82. public enum EnumWithMethod {
    
83.   Enum1,Enum2,Enum3;
    
84.   public String getName(){
    
85.     return this.getName();
    
86. }
    
87. 
    
88. public static void main(String[] args) {
    
89.   EnumWithMethod e1=EnumWithMethod.Enum1;
    
90.   System.out.println(e1.getName());
    
91. }
    
92. 
    
93. }
    
94. 
    
95. 一定可以编译，最好不要运行它，结果你会 很郁闷的！（这个原因，这里不说了）
    
96. 
    
97. 2.实现接口：
    
98. 枚举可以接口，肯定嘛，能够定义方法，肯定可以实现接口嘛。
    
99. public enum EnumImplementsInferface implements ForImpl {
    
100.   E1,E2;
     
101.   public voidmethod()
     
102.     {
     
103.      //DO Nothing
     
104.     }
     
105. }
     
106. interface ForImpl{
     
107.   public voidmethod();
     
108. }
     
109. 3.不能扩展与不能被扩展：
     
110.   你会发现你的枚举在定义的时候不能extends其他的类，也不能被extends。
     
111.   // enumA extends Object{}
     
112.    // classExtendsEnum extends EnumImplementsInferface{}
     
113. 
     
114.    自然你会想到这里方法不能是abstract的，其实方法都是final方法，不是吗？
     
115.    对于为什么不能继承或者被继承，你可以去思考，我觉得应该两方面来看，正方：为什么要继承呢？枚举是常数集合，继承有什么用呢？我可以任意的取值，并且不需要通过继承来达到扩展的目的。反方：继承可以提高重用性，特别是一些方法的重用等等。所以，未来怎么走，看SUN的啦！
     
116. 
     
117. 4.特殊规定：
     
118.    若你比较细心或者有怀疑精神的话，你可能会发现枚举值只能在最前段定义， 方法等等都在后面定义，试试吧！
     
119. 
     
120. 5.构造器：
     
121. 枚举有构造器，但是构造器只能用private限定。默认也是private，这也就是说枚举通过new关键字不能实例化。
     
122. 
     
123. private Enum  WithMethod() { }
     
124. 
     
125. 6.特殊 “值”类：
     
126. 既然有构造器，那么构造器就可以带参数，所以我们构造带有参数的实例。看下面的代码：
     
127. public enum EnumVauleClass {
     
128.    
     
129.   EVC1("No.1"),EVC2("No.2"),EVC3("No.3");
     
130.   private  String name;
     
131.   private  EnumVauleClass(String name){
     
132.    this.name=name;
     
133.   }
     
134.   public String getName(){
     
135.    return name;
     
136.   }
     
137.    public static void  main(String[] args)
     
138.     {
     
139.      EnumVauleClass  evc1=EnumVauleClass.EVC1;
     
140.       System.out.println(evc1);
     
141.     }
     
142. }
     
143. 这里我们可以看出来，我们实例化了三个实例变量EVC1-EVC3，看到14行，是否发现我们这里的实例并没有带有参数在main方法中！？其实这正是我们要说的我们的类实例是定义在枚举类里面的，我们仅仅引用一个常量实例。这里所说都是基础，为后面的“值”类做铺垫。
     
144. 
     
145. 再说“值”类，我们改改代码：
     
146. 
     
147. public enum EnumVauleClass1 {
     
148. EVC1("No.1") {
     
149.    public  String getName() {
     
150.     return "I'm "+EVC1.name;
     
151.    }
     
152. };
     
153. private String name;
     
154. private   EnumVauleClass1(String name){
     
155.   this.name=name;
     
156.   }
     
157. public String getName(){
     
158.    return name;
     
159. }
     
160. 
     
161. public static void  main(String[] args) {
     
162.   EnumVauleClass1   evc1=EnumVauleClass1.EVC1;
     
163.   System.out.println(evc1.getName());
     
164. }
     
165. }
     
166. 若你对代码中2-6行的代码感到有问题，这是自然的！
     
167. 
     
168. 我们在枚举里面好像定义了一个内部类似的，但是这个叫做“值”类，这是我的讲法。真正的名称“值限定” 类。再看看结果并不是No.1，而是I'mNo.1，证明这里是覆盖 了“父类”的方法getName()，嗯？其实我个人认为，SUN的做法是把全面面向对象发挥到个个方面。不多说了，最后我还告诉大家一个秘密，呵呵！
     
169. 其实，我们说有的枚举都继承了java.lang.Enum类,前面说它不能继承的吗？
     
170. 呵呵，你看看你的定义的枚举中，一定继承有Enum中的可继承的方法。

复制代码

你把枚举看成一个普通类，他的构造方法是私有的，  里面的元素就相当于普通类中的public static 修饰的对象