枚举总结

/*

1、枚举：枚举就是一个类，也即一种数据类型，引用数据类型。只不过是一个特殊的类。
这个类的引用（变量）或者这种数据类型的变量（引用），它的值是由定义该数据类型的人来指定的，即
它的取值是在枚举中定义好的，就那么几个值，如果不是这些列出来的值，编译器在编译的时候就会报错。

2、枚举的好处:将一种数据类型的所有取值限定在指定范围内。使得该数据类型的变量在取值时，不会出现非法赋值的
情况，如果有，则可以在编译时期就被发现，避免了一些错误赋值导致的问题发生。

3、枚举的定义：
enum 枚举类型名 //枚举是一种特殊的类，所以其和普通类一样，如果定义在外部，则可被public/默认修饰，如果
//定义在内部成员位置上，则可以被public/protected/默认/private修饰。
{
枚举元素1,枚举元素2,枚举元素3,.....,枚举元素n;
//所有的枚举元素都是本类的一个引用，指向的是该类对象或者该类的子类对象。且都是
//公共静态常量（即public final static）

成员;
//包括成员方法和成员变量的定义，包括构造函数在内。所有的成员定义都必须在枚举元素列表的后面定义。
//另：构造方法默认是空参数的构造方法，且是私有的（private），如果要自定义构造方法，则也必须声明
//为私有(即private)。

}

4、枚举的用法：枚举是一种特殊的类，所以用法和类是一致的。即 枚举类型名 枚举变量名 = 枚举类型名.枚举元素名。

5、枚举实现的原理：可以通过普通类来模拟枚举的实现原理。

实现过程中关键字：静态常量，私有化构造方法，本类对象，属于本类的对象的成员方法

package cn.itcast.day25;

//自定义类来模拟枚举类

class WeekDay
{
	private WeekDay(){}//禁止外部创建本类对象

	public final static WeekDay SUN = new WeekDay(); //定义本类引用的所有取值。
	public final static WeekDay MON = new WeekDay();
	public final static WeekDay TUS = new WeekDay();
	public final static WeekDay WEN = new WeekDay();
	public final static WeekDay THI = new WeekDay();
	public final static WeekDay FRI = new WeekDay();
	public final static WeekDay SAT = new WeekDay();

	public WeekDay nextDay()
	{
		if(this == SUN)
			return MON;
		if(this == MON)
			return TUS;
		if(this == TUS)
			return WEN;
		if(this == WEN)
			return THI;
		if(this == THI)
			return FRI;
		if(this == FRI)
			return SAT;
		return SUN;
	}
	public String toString()
	{
		if(this == SUN)
			return "SUN";
		if(this == MON)
			return "MON";
		if(this == TUS)
			return "TUS";
		if(this == WEN)
			return "WEN";
		if(this == THI)
			return "THI";
		if(this == FRI)
			return "FRI";
		return "SAT";
	}
}
public class EnumTest 
{
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
		WeekDay day = WeekDay.SUN;
		System.out.println(day.nextDay());
	}
	

}

　　6、用JDK中的enum定义自定义的枚举类TrafficLamp

public abstract enum TrafficLamp
	{
		RED(30) //默认的不带参数的构造方法不存在了，所以必须指定是调用哪一个带参数的构造方法，用"()"标明。
		{
			public TrafficLamp nextLamp()
			{
				return GREEN;
			}
		},
		GREEN(30)
		{			//"{}"表示GREEN，这个元素指向的是TrafficLamp的子类的对象，子类为匿名内部类，
					//实现了父类的抽象方法，且根据"(30)"在创建该子类对象时，通过子类对象的不带参数的构造函数（即默认
					//构造函数）调用父类TrafficLamp的带参数的构造函数"Traffic(int)"。

			public TrafficLamp nextLamp()
			{
				return YELLOW;
			}
		},
		YELLOW(5)  //这条语句会做这样的事情：
				   //定义了一个匿名内部类，其父类是TrafficLamp，并且创建了一个该匿名内部类的对象，最后将该对象
				   //赋值给了父类TrafficLamp的引用YELLOW。
		{
			public TrafficLamp nextLamp()
			{
				return RED;
			}
		};  //最后面的这个分号必须有，表示以上是定义枚举元素列表。

		public abstract TrafficLamp nextLamp(); //抽象方法

		private int time; //私有成员变量

		private TrafficLamp(int time) //1，构造方法必须被私有 2，默认的不带参数的构造方法不存在了
		{this.time = time;} 
	}
	//编译后的源文件一共会有四个类文件(.class文件)，即：
	//					TrafficLamp.class 、TrafficLamp$1.class 、TrafficLamp$2.class 、TrafficLamp$3.class 

　　

7、java中JDK提供的枚举中常用方法:
valueOf(),values(),toString(),getClass(),getName()等。

*/

 

转载于:https://www.cnblogs.com/wllbelief-win/p/4437867.html