枚举是java5.0的新特性，首先枚举是一个类，它的每个成员是它的一个实例对象。所以,在比较两个枚举类型的值时，永远不需要调用
equals,而直接使用"=="看可以了。
看实例分析： 

package com.enumtest; 

 import java.util.Arrays; 

 public class EnumTest 

 { 
 public enum WeekDay // 内部类
  {  SUN(2), MON(1), TUE, WED, THR, FRI, SAT;
   private WeekDay()
   {
    System.out.println("first");
   }  private WeekDay(int x)
   {
    System.out.println("second");
   } }
     public static void main(String[] args)
  {  WeekDay week2 = WeekDay.FRI;
   System.out.println(week2.TUE);
   System.out.println(week2);
   System.out.println(week2.name());
   System.out.println(week2.ordinal());
   System.out.println("valueof :" + week2.valueOf("SUN"));
   System.out.println("-------------------------");
   System.out.println(week2.values().length);
   String str = Arrays.toString(week2.values());
   System.out.println(str); }
    public enum TrafficLamp 
  {
   RED(30) // RED 理解 由TrafficLamp 的一个子类实现
   {
    public TrafficLamp nextLamp()
    {
     return GREEN;
    }
   },
   GREEN(45)
   {
    public TrafficLamp nextLamp()
    {
     return YELLOW;
    }
   },
   YELLOW(5)
   {
    public TrafficLamp nextLamp()
    {
     return RED;
    }
   };
   public abstract TrafficLamp nextLamp();  private int time;
  private TrafficLamp(int time)
   {
    this.time = time;
   }
    }
   }


上面程序打印结果：
second
second
first
first
first
first
first
TUE
FRI
FRI
5
valueof :SUN
-------------------------
7
[SUN, MON, TUE, WED, THR, FRI, SAT]
分析：
程序首先定义了一个WeekDay枚举，它里面定义了7个实例，有2个构造方法，一个带参数，一个不带参数，
SUN(2)表示SUN实例是调用private WeekDay(int x)带参数的方法构造的。
WeekDay week2 = WeekDay.FRI;
程序开始运行，加载WeekDay构造7个实例，SUN(2), MON(1)是调用带参数构造方法构造，所以打印2个second,
后面5个实例打印first.
接着打印week2.TUE为TUE，week2为FRI不难理解，week2.name()为此枚举的名字打印FRI,
week2.ordinal()打印此枚举实例在枚举初始化时的位置，枚举初始化第一个实例的值为0，所以
FRI的ordinal()为5。
valueOf方法返回以枚举名字为参数的枚举实例，参数为"SUN",所以打印SUN.
values()方法返回次枚举中实例的数组表示，长度为7，week2.values().length打印值为7.
最后打印values()返回的枚举数组的字符串表示形式[SUN, MON, TUE, WED, THR, FRI, SAT]。

上面程序还有一个内部类枚举TrafficLamp，内含有一个抽象方法public abstract TrafficLamp nextLamp();
作为枚举内部的实例RED,GREEN,YELLOW必需要实现类的抽象方法，所以在枚举的内部加上抽象方法，可以让枚举
的每个实例以不同的实现方式实现，枚举中还可以定义自己的属性和方法。

看下面用普通类型模拟枚举的实现：

public class WeekDays
 {
  private WeekDays()
  {
  }
   public WeekDays nextDay()
  {
   if (this == SUN)
    return MON;
   else
    return SUN;
  }
   public static final WeekDays SUN = new WeekDays();
   public static final WeekDays MON = new WeekDays();
   public String toString()
  {
   return this == SUN ? "sun" : "mon";
  }
 }


枚举要限定对象实例的数量，要外面不能new,所以构造方法写成private,
WeekDays类中定义了2个static final的实例，SUN,MON，就是表示模拟枚举类中只能引用2个实例，
类中还可以定义自己的方法nextDay()，重写了toString方法。

看下面也是同样可以在类中定义抽象的方法，让每个类的实例去单独的实现：

private WeekDays(){}
     public static final WeekDays SUN = new WeekDays(){
     @Override
   public WeekDays nextDay()
   {
    
    return MON;
   }};
     public static final WeekDays MON = new WeekDays(){  @Override
   public WeekDays nextDay()
   {
    
    return SUN;
   }};
     public abstract WeekDays nextDay();


   
 用抽象类和抽象方法把上面nextDay()方法中大量的if-else语句转移成一个个独立的类的具体实现了。 
还有，如果枚举中只有一个成员就可以作为一种单例的实现方式，相信大家都能理解。好了，有关java的
枚举就介绍到这里了，谢谢。