——枚举

枚举

     枚举是JDK1.5以后提供的新特性。枚举是一个特殊的类， 其中的每一个元素都是该类的一个对象。

     枚举就相当于一个类，其中也可以有构造方法，成员变量，普通方法和抽象方法。

     注：枚举元素必须位于枚举的最开始部分，枚举元素之间用逗号隔开，结尾用"；"分号与其他成员隔开。

 枚举的构造方法：

      一，枚举的构造方法必须是私有的，

      二，枚举元素如果后面不加带参的括号，则默认调用无参构造方法。

  作用：

    枚举就要让某个类型的变量的取值只能为若干个固定值中的一个， 否则编译错误。

    比如：一周只能有星期一到星期天7天。

枚举类的方法：

String name() 返回此枚举常量的名称，在其枚举声明中对其进行声明。

int ordinal() 返回身在枚举中的位置。  

static valueOf(String name) 返回带指定名称的枚举常量。

values() 返回的是枚举的所有元素的一个数组。

定义枚举的语法：用enum关键字

    访问修饰符 enum 枚举名称{

    }
枚举中重写了toString方法，其默认返回值是枚举元素的名称。

枚举的示例代码：

package com.itheima.io.file;

/**
 * 交通灯模拟
 * @author wuyong
 *
 */
public class LampDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//打印出枚举的所有元素：
		System.out.println("===========Values=============");
		Lamp[] lamps = Lamp.values();
		for (Lamp lamp : lamps) {
			System.out.println(lamp.name());
		}
		//输出对应名称的元素
		System.out.println("===========Value=============");
		System.out.println(Lamp.valueOf("RED"));
		System.out.println("=============模拟=================");
		//下一个灯
		Lamp nextLamp = null;
		//红灯，及下一个灯
		System.out.println(Lamp.RED + "亮了" + Lamp.RED.time + "秒");
		nextLamp = Lamp.RED.nextLamp();
		System.out.println(nextLamp + "亮了" + nextLamp.time + "秒");
		
		//黄灯，及下一个灯
		nextLamp = Lamp.YELLOW.nextLamp();
		System.out.println(nextLamp + "亮了" + nextLamp.time + "秒");
		
		//绿灯，及一个灯
		nextLamp = Lamp.GREEN.nextLamp();
		System.out.println(nextLamp + "亮了" + nextLamp.time + "秒");
	}

	public enum Lamp{
		//红灯
		RED(15) {
			@Override
			Lamp nextLamp() {
				return YELLOW;
			}
			public String toString(){
				System.out.print("红灯");
				return "";
			}
		},
		//黄灯
		YELLOW(3) {
			@Override
			Lamp nextLamp() {
				return GREEN;
			}
			public String toString(){
				System.out.print("黄灯");
				return "";
			}
		},
		//绿
		GREEN(15) {

			@Override
			Lamp nextLamp() {
				return RED;
			}
			public String toString(){
				System.out.print("绿灯");
				return "";
			}
		};
		//构造方法，跳转到下一个灯，交由每个灯自己去实现。
		abstract Lamp nextLamp();
		//灯亮的时间
		private int time;
		//构造函数
		private Lamp(){}
		private Lamp(int time){this.time = time;}
	}
}

用普通类模拟枚举的功能：

步骤：

    1，将构造函数私有；

    2，自定义固定个数的本来对象的静态常量，并初始化对象；

示例代码：

package com.itheima.io.file;

/**
 * 用普通类实现枚举的功能
 * @author wuyong
 *
 */
public class EnumClassDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(EnumClass.LOCK);
		System.out.println(EnumClass.UNLOCK);
		EnumClass.LOCK.isLock();
		EnumClass.UNLOCK.isLock();
	}

}
/**
 * 普通类模拟枚举的功能
 * @author wuyong
 *
 */
abstract class EnumClass{
	private EnumClass(){};
	public static final EnumClass LOCK = new EnumClass() {
		@Override
		void isLock() {
			System.out.println("锁锁上了");
		}
	};
	public static final EnumClass UNLOCK = new EnumClass() {
		@Override
		void isLock() {
			System.out.println("锁打开了");
		}
	};
	abstract void isLock();
}

枚举还可以用来设计单例模式：

示例代码：

package com.itheima.io.file;

/**
 * 枚举的单例模式
 * @author wuyong
 *
 */
public class EnumSingleDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Single single1 = Single.SINGLE;
		Single single2 = Single.SINGLE;
		System.out.println("single1 == single2 : " + (single1 == single2));
		System.out.println("single1.hashCode == single2.hashCode : " + (single1.hashCode() == single2.hashCode()));
	}
	
	public enum Single{
		SINGLE{
			@Override
			void address() {
				System.out.println(this.hashCode());
			}
		};
		abstract void address(); 
	}
}