1.   概念

　　首先,枚举并不是一种新技术,而是一种基础数据类型.它隶属于两种基础类型中的值类型,如下:

 2.   为什么要有枚举

　　枚举在真正的开发中是非常常用的,它的作用很简单也很纯粹：它定义了一种规范，就是要让某个类型的变量的取值只能为若干个固定值中的一个，也就是要符合它定义的规范.它可以让编译器在编译时就可以识别程序中填写的非法值,一定程度上防止了运行时的非法类型值错误.

　　例如:要定义星期几的变量,如果用普通变量1-7   分别表示星期一到星期日,但有人可能写成int weekday=0.这种错误只能到运行时才能发现，编译是没问题的。但如果用枚举代替普通变量，就可将错误在编译时识别。

　　枚举本身当然是一个类，它的定义与使用与普通类很类似，而每个枚举变量都相当于类的一个对象。下面将分别介绍枚举的基本使用、带有构造方法的枚举、带有抽象方法的枚举。如下：

3.  基本使用

     实例：

public class EnumTest2 {
	public static void main(String[] args) {
		WeekDay weekDay2 = WeekDay.FRI;
		//使用1：toString()方法
		System.out.println(weekDay2);//输出：FRI
		//使用2：name()方法
		System.out.println(weekDay2.name());//输出：FRI
		//使用3：ordinal()方法
		System.out.println(weekDay2.ordinal());	//输出：5
		//使用4：枚举变量的反射
		System.out.println(WeekDay.valueOf("SUN").toString());//输出：SUN
		//使用5：获取枚举的长度
		System.out.println(WeekDay.values().length);//输出：7
	}
	/**
	 * 定义枚举类--这里作为测试类的一个子类
	 */
	public enum WeekDay{
		SUN,MON,TUE,WED,THI,FRI,SAT;
	}		
}

4.  带有构造方法的枚举

　　首先有两点要求：

　　?  要求所有的东西都要在枚举变量之后写

　　?  构造方法必须是私有的

　　使用：

　　?  当使用某一个枚举变量时，就会将所有的枚举变量都实例化并缓存；以后再次用到时不会再次实例化。

　　?  与普通类一样，枚举变量采用哪一个构造方法，也是根据参数的类型与个数而定。

　　实例：

public class EnumTest {
	public static void main(String[] args) {
		WeekDay weekDay = WeekDay.MON;	
		System.out.println("-------------");
		WeekDay weekDay2 = WeekDay.TUE;	
		/*
		 * 输出结果如下：
		 	构造方法3
			构造方法2
			构造方法1
			构造方法1
			构造方法1
			构造方法1
			构造方法1
			-------------（结束）
		 * 上面调用MON时，所有的枚举变量的构造方法都被调用；再次调用TUE时没有再调用
		 * 表明，当使用某一个枚举变量时，就会将所有的枚举变量都实例化并缓存；
		 * 以后再次用到时不会再次实例化
		 */
	}
	/**
	 * 定义枚举类--这里作为测试类的一个子类
	 */
	public enum WeekDay{
		//与普通类一样，枚举变量采用哪一个构造方法，也是根据参数的类型与个数而定
		//如下SUN将采用构造方法3；MON采用构造方法2；其余的都采用构造方法1
		SUN(1,2),MON(1),TUE(),WED,THI,FRI,SAT;
		
		//构造方法1：
		private WeekDay(){System.out.println("构造方法1");}
		//构造方法2
		private WeekDay(int day){System.out.println("构造方法2");}
		//构造方法3
		private WeekDay(int day,int day2){System.out.println("构造方法3");}
	}

5.  带有抽象方法的枚举

　　枚举类中的逻辑方法，肯定会涉及到所有的枚举变量，要进行逻辑判断就必须要使用大量的if…else语句。而使用抽象方法就可以将if…else语句转移成一个个独立的类。

　　如，下面的交通灯枚举类中，若要计算下一个灯的颜色，普通的写法肯定要判断，如果当前“红灯”那么下一个灯为“绿灯”；如果当前为“绿灯”那么下一个灯为“黄灯”……；而如果使用抽象方法则可将一系列判断转移为一个个独立的类。实例：

	/**
	 * 定义枚举类
	 */
	public enum TrafficLamp{
		//"{}"表示一个匿名子类，所以就可以重写枚举的抽象方法。这里将if..else转化为了3个匿名子类
		RED(30){
			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;}//构造方法
	}

6.  普通类模拟枚举类

　　下面简单用普通类来模拟一下枚举类

　　要素：

　　?  私有的构造方法

　　?  用一个个公有的静态成员变量模拟枚举变量

　　?  可以有若干公有方法或

　　实例：

package TestPage;

public abstract class WeekDay {
	//?	私有的构造方法
	private WeekDay(){}
	//?	公有的静态成员变量SUN、MON模拟枚举变量，"{}"表示一个匿名子类
	public final static WeekDay SUN = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return MON;
		}
	};
	public final static WeekDay MON = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return SUN;
		}
	};	
	//  抽象方法-转移计算nextDay的逻辑
	public abstract WeekDay nextDay();
	
	//普通的计算nextDay的方法，要用if...else判断
	/*public WeekDay nextDay(){
			if(this == SUN){
				return  MON;
			}else{
				return SUN;
			}
		}
	*/
	//公有方法
	public String toString(){
		return this==SUN?"SUN":"MON";
	}
}

7.  总结

　　枚举是一个较特殊的“类”，枚举变量相当于枚举类的一个个对象。它定义一种规范，让枚举变量的取值必须符合它定义的规范，只能为若干个固定值中的一个，从而在一定程度上防止了运行时的非法类型值错误.

原文：http://blog.csdn.net/wang379275614/article/details/39652245