在听张老师视频的时候，刚开始理解枚举类中的第一行表示的是该类的一个对象。可是，后面讲着讲着，似乎就变成子类对象了（继承了这个枚举类的子类的对象）。

大家是怎么理解的？

枚举就是一个对象，这个对象也包括子类对象的。下面通过两段代码体会一下枚举的使用吧：
（1）一个相对简单的枚举：
public enum ColorEnum {  
     RED,  
     GREEN,  
     BLUE;  

     public static void main(String[] args) {  
         // 获得枚举实例序号  
         int index = RED.ordinal();RED.compareTo(RED);  
         // 返回所有的枚举实例  
         ColorEnum[] colors = ColorEnum.values();  
         // 获得实例的名称  
         String colorName = GREEN.name();  
         // 通过实例名称来获得枚举实例  
         ColorEnum color = ColorEnum.valueOf(colorName);  
         /* 比较两个枚举的方法一  
          * 比较方式是比较枚举的ordinal  
          */  
         int compare = BLUE.compareTo(BLUE);  
         /* 比较两个枚举的方法二  
          * 枚举支持直接用这种逻辑表达式方式作比较  
          */
         boolean isEqual = RED == GREEN;  
         // 枚举支持直接用switch作选择  
         switch (BLUE) {  
             case RED: break;  
             case GREEN: break;  
             case BLUE: break;  
             default: break;  
         }  

     }
}
（2）一个不那么简单的枚举：
import java.awt.Color;  
import java.io.Serializable;      
/**  
  * 颜色的枚举  
  * 是能实现接口  
  * 不能继承  
  * @author
  */
public enum ColorEnum implements Serializable {         
     /**  
      * 红色  
      */
     RED(255, 0, 0) {              
         public void doSomeThing() {  
             System.out.println(name());  
         }              
     },  
     /**  
      * 绿色  
      */
     GREEN(0, 255, 0) {              
         public void doSomeThing() {  
             System.out.println(ordinal());  
         }              
     },  
     /**  
      * 蓝色  
      */
     BLUE(0, 0, 255) {  
            
         @Override
         public void doSomeThing() {  
             System.out.println(toString());  
         }              
     };         
     /**  
      * 颜色  
      */
     private Color color;      
     /**  
      * 实例化颜色枚举  
      * 枚举字段的实例化将会调用这个构造方法  
      * 必须用private修饰  
      * 代表只有本枚举自己能够构造  
      * 枚举的实例都是静态的  
      * 会在第一次访问的时候就生成  
      * @param r 红色  
      * @param g 绿色  
      * @param b 蓝色  
      */
     private ColorEnum(int r, int g, int b) {  
         this.color = new Color(r, g, b);;  
     }      
     /**  
      * @return 颜色实体  
      */
     public Color getColor() {  
         return color;  
     }         
     /**  
      * 定义抽象方法  
      * 实例必须实现它  
      */
     abstract void doSomeThing();  
     public static void main(String[] args) {  
         Color color = RED.getColor();  
         GREEN.doSomeThing();  
     }  
}

看起来感觉还算正确，楼上好强！
不过，枚举是子类对象的话，那么每个子类就只有1个对象，岂不浪费？

你好
枚举是对有限数量的一类事物的描述。比如星期、月份等。
枚举中元素的类型就是这类事物的类型，枚举构造方法必须是私有的，不能直接new枚举类的对象。
如果枚举对象要使用枚举类中的抽象方法，就需要枚举中的元素实现抽象方法自定义要实现的功能。
也就是创建子类对象用匿名内部类实现。
如星期枚举类

1. public class EnumTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 WeekDay w=WeekDay.SUN;
   
6.                 System.out.println(w.nextDay().toString());
   
7.         }
   
8.         public enum WeekDay
   
9.         {
   
10.                 //给枚举类中的元素初始化，创建子类对象实现抽象方法
    
11.                 SUN
    
12.                 {
    
13.                         public WeekDay nextDay()
    
14.                         {
    
15.                                 return MON;
    
16.                         }
    
17.                 },
    
18.                 MON
    
19.                 {
    
20.                         public WeekDay nextDay()
    
21.                         {
    
22.                                 return TUE;
    
23.                         }
    
24.                 },
    
25.                 TUE
    
26.                 {
    
27.                         public WeekDay nextDay()
    
28.                         {
    
29.                                 return WEN;
    
30.                         }
    
31.                 },
    
32.                 WEN
    
33.                 {
    
34.                         public WeekDay nextDay()
    
35.                         {
    
36.                                 return THUR;
    
37.                         }
    
38.                 },
    
39.                 THUR
    
40.                 {
    
41.                         public WeekDay nextDay()
    
42.                         {
    
43.                                 return FRI;
    
44.                         }
    
45.                 },
    
46.                 FRI
    
47.                 {
    
48.                         public WeekDay nextDay()
    
49.                         {
    
50.                                 return SAT;
    
51.                         }
    
52.                 },
    
53.                 SAT
    
54.                 {
    
55.                         public WeekDay nextDay()
    
56.                         {
    
57.                                 return MON;
    
58.                         }
    
59.                 };
    
60.                 public abstract WeekDay nextDay();
    
61.         }
    
62. }

复制代码