高新视频中讲枚举可以看作一个类，他的元素可以看作类的一个实际对象，但是代码编写时，又讲到‘元素相当于枚举的一个子类实现的’，
我想问一下，枚举中，他的元素是作为一个实际对象，还是一个子类？
下面的代码中，感觉是一个子类？

1. //交通灯
   
2. public enum TrafficLamp{
   
3. RED(30){
   
4.   public TrafficLamp nextLamp(){   
   
5.    return GREEN;
   
6.   }
   
7. },
   
8. GREEN(10){
   
9.   public TrafficLamp nextLamp(){
   
10.    return YELLOW;
    
11.   }
    
12. },
    
13. YELLOW(30){
    
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. }
    
24. <p> </p>

复制代码

enum的类编译后的结尾还是.class; 只是特殊点。 里面的元素看作子类。
推荐两篇文章看看：
http://www.ibm.com/developerworks/cn/java/j-enums.html  入门
http://www.ibm.com/developerworks/cn/java/j-tiger04195/#Constructors  深入

1. /**
   
2. * 2013-8-2下午12:35:37
   
3. * EnumTest.java
   
4. * Administrator
   
5. */
   
6. package com.itheima.test;
   
7. 
   
8. /**
   
9. * @author Administrator
   
10. * @time 2013-8-2下午12:35:37
    
11. */
    
12. public class EnumTest {
    
13. 
    
14.         public static void main(String[] args) {
    
15.                 Lamp red=Lamp.RED;
    
16.                 //enum里面有抽象方法时，enum元素是其一个内部匿名子类对象，其父类是enum
    
17.                 System.out.println(red.getClass().toString());
    
18.                 System.out.println(red.getClass().getSuperclass().toString());
    
19.                 Lamp1 red1=Lamp1.RED;
    
20.                 //没有抽象方法时，enum元素是就是该enum的一个对象，父类是Enum
    
21.                 System.out.println(red1.getClass().toString());
    
22.                 System.out.println(red1.getClass().getSuperclass().toString());
    
23.                
    
24.         }
    
25. }
    
26. 
    
27. enum Lamp{
    
28.         RED{
    
29.                 /* (non-Javadoc)
    
30.                  * @see com.itheima.test.Lamp#getName()
    
31.                  */
    
32.                 @Override
    
33.                 public String getName() {
    
34.                         // TODO Auto-generated method stub
    
35.                         return "red";
    
36.                 }
    
37.         },GREED{
    
38.                 /* (non-Javadoc)
    
39.                  * @see com.itheima.test.Lamp#getName()
    
40.                  */
    
41.                 @Override
    
42.                 public String getName() {
    
43.                         // TODO Auto-generated method stub
    
44.                         return "greed";
    
45.                 }
    
46.         },YELLOW{
    
47.                 /* (non-Javadoc)
    
48.                  * @see com.itheima.test.Lamp#getName()
    
49.                  */
    
50.                 @Override
    
51.                 public String getName() {
    
52.                         // TODO Auto-generated method stub
    
53.                         return "yellow";
    
54.                 }
    
55.         };
    
56.         abstract public String getName();
    
57. }
    
58. enum Lamp1{
    
59.         RED,GREED,YELLOW
    
60.        
    
61. }

复制代码

chslzj 发表于 2013-8-2 12:59

奥，明白了，谢谢啊

sergio 发表于 2013-8-2 11:20
enum的类编译后的结尾还是.class; 只是特殊点。 里面的元素看作子类。
推荐两篇文章看看：
http://www.ibm. ...

好的，谢谢

是该枚举类的子类对象。所以说，是对象。 该对象是  :  public static final 匿名对象;

RED(30){

public TrafficLamp nextLamp(){   

  return GREEN;

  }
}  内部是这样的：public static final Lamp RED = new Lamp(){
public TrafficLamp nextLamp(){   

  return GREEN;

  }
}所以RED为Lamp类的一个匿名子类对象！！！