1. public enum TrafficLamp
   
2. //RED,GRREN<FONT color=red>难道就相当于new了一个吗?></FONT>
   
3. {
   
4. RED(30){   public TrafficLamp nextLamp(){
   
5. return GREEN;
   
6. }
   
7. },
   
8. GREEN(45){   
   
9. public TrafficLamp nextLamp(){
   
10. return YELLOW;
    
11. }
    
12. },
    
13. YELLOW(5){
    
14. public TrafficLamp nextLamp(){
    
15. return RED;
    
16. }
    
17. };
    
18. public abstract TrafficLamp nextLamp();
    
19. private int time;
    
20. private TrafficLamp(int time){
    
21. this.time = time;
    
22. }
    
23. }

复制代码

/*就是想问下这个RED,GREEN...是不是一定义就相当于new TrafficLamp对象.......
还有为什么枚举类里面可以创建抽象类呢?枚举类相当于是什么呢? 说下原理,谢谢.*/
都整蒙圈了

....{:soso_e120:}....

1. package enumtest;
   
2. public class EnumDemo {
   
3. 
   
4.         /**
   
5.          * 关于枚举。
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 System.out.println(enu.A.getClass());
   
10.         }
    
11. 
    
12. }
    
13. 
    
14. enum enu {
    
15.         A, B, C, D;
    
16. }
    
17. 输出：class enumtest.enu

复制代码

说明A是一个对象，它的字节码文件是class enumtest.enu，还有枚举enu定义在了class EnumDemo{}外，也就说明enu是一个类，enu会在像类一样加载，A,B,C,D是这个类的实例。

1. package enumtest;
   
2. 
   
3. public class EnumDemo {
   
4. 
   
5.         /**
   
6.          * 关于枚举。
   
7.          *
   
8.          * @param args
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 System.out.println(enu.A.getClass());
    
12.                 System.out.println(enu.A.getClass().getSuperclass());
    
13.         }
    
14. 
    
15. }
    
16. 
    
17. enum enu {
    
18.         A {
    
19.                 void method() {
    
20.                         System.out.println("A");
    
21.                 }
    
22.         },
    
23.         B {
    
24.                 void method() {
    
25.                         System.out.println("A");
    
26.                 }
    
27.         },
    
28.         C {
    
29.                 void method() {
    
30.                         System.out.println("A");
    
31.                 }
    
32.         },
    
33.         D {
    
34.                 void method() {
    
35.                         System.out.println("A");
    
36.                 }
    
37.         };
    
38.         abstract void method();
    
39. }
    
40. 输出：class enumtest.enu$1
    
41.          class enumtest.enu
    

复制代码

既然enu是类，可以定义它为抽象类，那么它的实例就必须要实现它的抽象方法，但是抽象方法不能被实例化，那么A,B,C,D用匿名内部类来了个实例化。所以输出它的字节码类为class enumtest.enu$1，字节码的父类为 class enumtest.enu。总之，就把枚举 enu的成员看成它的实例就ok了，当enu是抽象时，成员看成enu子类的实例，只不过这个子类在其内部！偶了！

其中的RED、GREEN可以理解为new TrafficLamp，其实是在创建TrafficLamp的实例，而在例子中，使用了带参的构造函数，并实现了抽象方法

枚举类是一种特殊的类。
首先枚举类是一种类，其他类可以有的，枚举类也可以有

但枚举类又是特殊的，特殊之处在于：
使用enum定义的枚举默认继承了java.lang.Enum类，Enum类实现了Comparabel, Serializable接口
枚举类的构造器只能使用private修饰
枚举类的所有实例都必须在枚举类中显示列出，否则这个枚举类将不能产生实例，并会自动添加public static final修饰符修饰这些实例

枚举类就是这样的一个特殊类

谢谢楼上两位生动的解答, 我在仔细去研究去了