MRH 马甲右手 uzons.com

1.所有创建的枚举类型都扩展于 java.lang.Enum. Enum 是在J2SE 5.0 里定义的一个新类，它本身不是枚举类型.在创建枚举类型时，必须用enum 关键字，不能直接地定义一个继承Enum的类来创建一个枚举类型，尽管所有创建的枚举类型实际上都是Enum 的子类.
2.枚举类型里定义的每一个值都是枚举类型的一个实例,缺省时都将映射到Enum(String name, int ordinal) 构造函数中.枚举类型可以使用参数为定义一些自己的构造函数。
另外要强调的两点:
一是这些枚举类型的构造函数都是私有的.它是不能被其它的类或者其它的枚举类型调用的. 而且这个私有修饰符是由编译器自动加的,如果我们定义这些构造函数时,在前面加上public 修饰符, 就会导致编译错误,
二是变量定义必须在枚举类型值定义之后
3.枚举类型每一个值都是public, static and final的.也就是说，这些值是唯一的而且一旦定义了是不能被重写或修改.而且尽管在枚举类型每一个值声明时没有出现static关键字，实际上值都是静态的, 而且我们不能在值前面加上static, public，final 修饰符
4.Switch语句里使用枚举类型时，一定不能在每一个枚举类型值的前面加上枚举类型的类名（case后面的值），否则编译器就会报错
5.在J2SE 5.0 的java.util 程序包中提供两个新类：EnumMap 和 EnumSet，这两个类与枚举类型的结合应用可使以前非常繁琐的程序变得简单方便.EnumMap 类提供了java.util.Map 接口的一个特殊实现，该接口中的键（key）是一个枚举类型
6.特定于常量的类主体：
提到枚举类型可以定义自己的函数，其实更进一步，枚举类型的每一个值都可以实现枚举类型里定义的抽象函数

下面举点例子看看他的简洁与美观性：

Demo 1：

package com.uzons.test;

/**
 * @author MRH
 *
 */
public class EnumDemo1 {
	enum Enum1{
		Small,Medium,Large,Other;
	}
	public static void main(String[] args) {
		for (Enum1 e : EnumDemo1.Enum1.values()) {
			System.out.println(e.name());
		}
	}
}

输出结果：

Small,Medium,Large,Other

可以查看一下他的编译后的源码：

package com.uzons.test;

import java.io.PrintStream;

public class EnumDemo1
{
	static final class Enum1 extends Enum
	{

		public static final Enum1 Small;
		public static final Enum1 Medium;
		public static final Enum1 Large;
		public static final Enum1 Other;
		private static final Enum1 ENUM$VALUES[];

		public static Enum1[] values()
		{
			Enum1 aenum1[];
			int i;
			Enum1 aenum1_1[];
			System.arraycopy(aenum1 = ENUM$VALUES, 0, aenum1_1 = new Enum1[i = aenum1.length], 0, i);
			return aenum1_1;
		}

		public static Enum1 valueOf(String s)
		{
			return (Enum1)Enum.valueOf(com/uzons/test/EnumDemo1$Enum1, s);
		}

		static
		{
			Small = new Enum1("Small", 0);
			Medium = new Enum1("Medium", 1);
			Large = new Enum1("Large", 2);
			Other = new Enum1("Other", 3);
			ENUM$VALUES = (new Enum1[] {
				Small, Medium, Large, Other
			});
		}

		private Enum1(String s, int i)
		{
			super(s, i);
		}
	}

	public EnumDemo1()
	{
	}

	public static void main(String args[])
	{
		Enum1 aenum1[];
		int j = (aenum1 = Enum1.values()).length;
		for (int i = 0; i < j; i++)
		{
			Enum1 e = aenum1[i];
			System.out.println(e.name());
		}

	}
}

这样可以看出以上所说的特点。

继续 Demo 2，

package com.uzons.test;

/**
 * @author MRH
 *
 */
public class EnumDemo2 {
	/* 还可以有构造方法 */
	public enum Enum2 {
		/*
		 * 通过括号赋值,而且必须有带参构造器和一属性跟方法，否则编译出错 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值
		 * 如果不赋值则不能写构造器，赋值编译也出错
		 */
		Small(234), Medium(32), Large(212), Other(451);

		private final int value;

		public int getValue() {
			return value;
		}

		// 构造器默认也只能是private, 从而保证构造函数只能在内部使用
		Enum2(int value) {
			this.value = value;
		}
	}
	public static void main(String[] args) {
		for (Enum2 e : Enum2.values()) {
			System.out.println(e.name() + "\t" + e.getValue());
		}
	}
}

输出结果：

Small    234
Medium    32
Large    212
Other    451

编译后：

package com.uzons.test;

import java.io.PrintStream;

public class EnumDemo2
{
	public static final class Enum2 extends Enum
	{

		public static final Enum2 Small;
		public static final Enum2 Medium;
		public static final Enum2 Large;
		public static final Enum2 Other;
		private final int value;
		private static final Enum2 ENUM$VALUES[];

		public int getValue()
		{
			return value;
		}

		public static Enum2[] values()
		{
			Enum2 aenum2[];
			int i;
			Enum2 aenum2_1[];
			System.arraycopy(aenum2 = ENUM$VALUES, 0, aenum2_1 = new Enum2[i = aenum2.length], 0, i);
			return aenum2_1;
		}

		public static Enum2 valueOf(String s)
		{
			return (Enum2)Enum.valueOf(com/uzons/test/EnumDemo2$Enum2, s);
		}

		static
		{
			Small = new Enum2("Small", 0, 234);
			Medium = new Enum2("Medium", 1, 32);
			Large = new Enum2("Large", 2, 212);
			Other = new Enum2("Other", 3, 451);
			ENUM$VALUES = (new Enum2[] {
				Small, Medium, Large, Other
			});
		}

		private Enum2(String s, int i, int value)
		{
			super(s, i);
			this.value = value;
		}
	}

	public EnumDemo2()
	{
	}

	public static void main(String args[])
	{
		Enum2 aenum2[];
		int j = (aenum2 = Enum2.values()).length;
		for (int i = 0; i < j; i++)
		{
			Enum2 e = aenum2[i];
			System.out.println((new StringBuilder(String.valueOf(e.name()))).append("\t").append(e.getValue()).toString());
		}

	}
}

看到这里，你懂的。

本文主要参考于：

http://cupoy.iteye.com/blog/248134

http://www.cnblogs.com/Fskjb/archive/2009/08/03/1537917.html

Enum, J2SE, Java