在Java中使用枚举

　　从C++转到Java上的程序员一开始总是对Java有不少抱怨，其中没有枚举就是一个比较突出的问题。那么为什么Java不支持枚举呢？从程序语言的角度讲，支持枚举意味着什么呢？我们能不能找到一种方法满足C++程序员对枚举的要求呢？那么现在就让我们一起来探讨一下这个问题。
　　
　　枚举类型（Enumerated Types）
　　
　　让我们先看下面这一段小程序：
　　
　　enum Day {SUNDAY, MONDAY, TUESDAY,
　　WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
　　
　　这种申明提供了一种用户友好的变量定义的方法，它枚举了这种数据类型所有可能的值，即星期一到星期天。抛开具体编程语言来看，枚举所具有的核心功能应该是:
　　
　　类型安全（Type Safety）
　　
　　紧凑有效的枚举数值定义 (Compact, Efficient Declaration of Enumerated Values)
　　
　　无缝的和程序其它部分的交互操作（Seamless integration with other language features）
　　
　　运行的高效率（Runtime efficiency）
　　
　　现在我们就这几个特点逐一讨论一下。
　　
　　1. 类型安全
　　
　　枚举的申明创建了一个新的类型。它不同于其他的已有类型，包括原始类型（整数，浮点数等等）和当前作用域（Scope）内的其它的枚举类型。当你对函数的参数进行赋值操作的时候，整数类型和枚举类型是不能互换的（除非是你进行显式的类型转换），编译器将强制这一点。比如说，用上面申明的枚举定义这样一个函数：
　　
　　public void foo(Day);
　　
　　假如你用整数来调用这个函数，编译器会给出错误的。
　　
　　foo(4); // compilation error
　　
　　假如按照这个标准，那么Pascal, Ada, 和C++是严格意义上的支持枚举，而C语言都不是。
　　
　　2. 紧凑有效的枚举数值定义
　　
　　定义枚巨的程序应该很简单。比如说，在Java中我们有这样一种"准枚举"的定义方法：
　　
　　public static final int SUNDAY = 0;
　　public static final int MONDAY = 1;
　　public static final int TUESDAY = 2;
　　public static final int WEDNESDAY = 3;
　　public static final int THURSDAY = 4;
　　public static final int FRIDAY = 5;
　　public static final int SATURDAY = 6;
　　
　　这种定义就似乎不够简洁。假如有大量的数据要定义，这一点就尤为重要，你也就会感受更深。虽然这一点不如其他另外3点重要，但我们总是希望申明能尽可能的简洁。
　　
　　3. 无缝的和程序其它部分的交互操作
　　
　　语言的运算符，如赋值，相等/大于/小于判定都应该支持枚举。枚举还应该支持数组下标以及switch/case语句中用来控制流程的操作。比如：
　　
　　for (Day d = SUNDAY; d = SATURDAY; ++d) {
　　switch(d) {
　　case MONDAY: ...;
　　break;
　　case TUESDAY: ...;
　　break;
　　case WEDNESDAY: ...;
　　break;
　　case THURSDAY: ...;
　　break;
　　case FRIDAY: ...;
　　break;
　　case SATURDAY:
　　case SUNDAY: ...;
　　}
　　}
　　
　　要想让这段程序工作，那么枚举必须是整数常数，而不能是对象（objects）。Java中你可以用equals() 或是 compareTo() 函数来进行对象的比较操作，但是它们都不支持数组下标和switch语句。
　　
　　4. 运行的高效率
　　
　　枚举的运行效率应该和原始类型的整数一样高。在运行时不应该由于使用了枚举而导致性能比使用整数有下降。
　　
　　假如一种语言满足这四点要求，那么我们可以说这种语言是真正的支持枚举。比如前面所说的Pascal, Ada, 和C++。很明显，Java不是。
　　
　　Java的创始人James Gosling是个资深的C++程序员，他很清楚什么是枚举。但似乎他有意的删除了Java的枚举能力。其原因我们不得而知。可能是他想强调和鼓励使用多态性（polymorphism），不鼓励使用多重分支。而多重分支往往是和枚举联合使用的。不管他的初衷如何，我们在Java中仍然需要枚举。
　　
　　Java中的几种"准枚举"类型
　　
　　虽然Java 不直接支持用户定义的枚举。但是在实践中人们还是总结出一些枚举的替代品。
　　
　　第一种替代品可以解释为"整数常数枚举"。如下所示：
　　
　　public static final int SUNDAY = 0;
　　public static final int MONDAY = 1;
　　public static final int TUESDAY = 2;
　　public static final int WEDNESDAY = 3;
　　public static final int THURSDAY = 4;
　　public static final int FRIDAY = 5;
　　public static final int SATURDAY = 6;
　　
　　这种方法可以让我们使用更有意义的变量名而不是直接赤裸裸的整数值。这样使得源程序的可读性和可维护性更好一些。这些定义可以放在任何类中。可以和其它的变量和方法混在一起。也可以单独放在一个类中。假如你选择将其单独放在一个类中，那么引用的时候要注重语法。比如"Day.MONDAY."。假如你想在引用的时候省一点事，那么你可以将其放在一个接口中（interface），其它类只要申明实现（implement）它就可以比较方便的引用。比如直接使用MONDAY。就Java接口的使用目的而言，这种用法有些偏，不用也罢！
　　
　　这种方法显然满足了条件3和4，即语言的集成和执行效率（枚举就是整数，没有效率损失）。但是他却不能满足条件1和2。它的定义有些啰嗦，更重要的是它不是类型安全的。这种方法虽然普遍被Java程序员采用，但它不是一种枚举的良好替代品。
　　
　　第二种方法是被一些有名的专家经常提及的。我们可以称它为"对象枚举"。即为枚举创建一个类，然后用公用的该类的对象来表达每一个枚举的值。如下所示：
　　
　　import java.util.Map;
　　import java.util.HashMap;
　　import java.util.Iterator;
　　import java.io.Serializable;
　　import java.io.InvalidObjectException;
　　public final class Day implements Comparable, Serializable {
　　private static int size = 0;
　　private static int nextOrd = 0;
　　private static Map nameMap = new HashMap(10);
　　private static Day first = null;
　　private static Day last = null;
　　private final int ord;
　　private final String label;
　　private Day prev;
　　private Day next;
　　public static final Day SUNDAY = new Day("SUNDAY");
　　public static final Day MONDAY = new Day("MONDAY");
　　public static final Day TUESDAY = new Day("TUESDAY");
　　public static final Day WEDNESDAY = new Day("WEDNESDAY");
　　public static final Day THURSDAY = new Day("THURSDAY");
　　public static final Day FRIDAY = new Day("FRIDAY");
　　public static final Day SATURDAY = new Day("SATURDAY");
　　/**
　　* 用所给的标签创建一个新的day.
　　* (Uses default value for ord.)
　　*/
　　private Day(String label) {
　　this(label, nextOrd);
　　}
　　/**
　　* ConstrUCts a new Day with its label and ord value.
　　*/
　　private Day(String label, int ord) {
　　this.label = label;
　　this.ord = ord;
　　++size;
　　nextOrd = ord + 1;
　　nameMap.put(label, this);
　　if (first == null)
　　first = this;
　　if (last != null) {
　　this.prev = last;
　　last.next = this;
　　}
　　last = this;
　　}
　　/**
　　* Compares two Day objects based on their ordinal values.
　　* Satisfies requirements of interface java.lang.Comparable.
　　*/
　　public int compareTo(Object obj) {
　　return ord - ((Day)obj).ord;
　　}
　　/**
　　* Compares two Day objects for equality. Returns true
　　* only if the specified Day is equal to this one.
　　*/
　　public boolean equals(Object obj) {
　　return super.equals(obj);
　　}
　　/**
　　* Returns a hash code value for this Day.
　　*/
　　public int hashCode() {
　　return super.hashCode();
　　}
　　/**
　　* Resolves deserialized Day objects.
　　* @throws InvalidObjectException if deserialization fails.
　　*/
　　private Object readResolve() throws InvalidObjectException {
　　Day d = get(label);
　　if (d != null)
　　return d;
　　else {
　　String msg = "invalid deserialized object: label = ";
　　throw new InvalidObjectException(msg + label);
　　}
　　}
　　/**
　　* Returns Day with the specified label.
　　* Returns null if not found.
　　*/
　　public static Day get(String label) {
　　return (Day) nameMap.get(label);
　　}
　　/**
　　* Returns the label for this Day.
　　*/
　　public String toString() {
　　return label;
　　}
　　/**
　　* Always throws CloneNotSupportedException; guarantees that
　　* Day objects are never cloned.
　　*
　　* @return (never returns)
　　*/
　　protected Object clone() throws CloneNotSupportedException {
　　throw new CloneNotSupportedException();
　　}
　　/**
　　* Returns an iterator over all Day objects in declared order.
　　*/
　　public static Iterator iterator() {
　　// anonymous inner class
　　return new Iterator()
　　{
　　private Day current = first;
　　public boolean hasNext() {
　　return current != null;
　　}
　　public Object next() {
　　Day d = current;
　　current = current.next();
　　return d;
　　}
　　public void remove() {
　　throw new UnsupportedOperationException();
　　}
　　};
　　}
　　/**
　　* Returns the ordinal value of this Day.
　　*/
　　public int ord() {
　　return this.ord;
　　}
　　/**
　　* Returns the number of declared Day objects.
　　*/
　　public static int size() {
　　return size;
　　}
　　/**
　　* Returns the first declared Day.
　　*/
　　public static Day first() {
　　return first;
　　}
　　/**
　　* Returns the last declared Day.
　　*/
　　public static Day last() {
　　return last;
　　}
　　/**
　　* Returns the previous Day before this one in declared order.
　　* Returns null for the first declared Day.
　　*/
　　public Day prev() {
　　return this.prev;
　　}
　　/**
　　* Returns the next Day after this one in declared order.
　　* Returns null for the last declared Day.
　　*/
　　public Day next() {
　　return this.next;
　　}
　　}
　　
　　枚举值被定义为公用静态对象（public static object）。此外该类含有私有构造函数；一个循环器（Iterator）用以遍历所有的值；一些Java中常用的函数，如toString()，equals()和compareTo()，以及一些方便客户程序调用的函数，如ord()，prev()，next()，first()和 last()。
　　
　　这种实现方法有很好的类型安全和运行效率（条件1和4）。但是去不满足条件2和3。首先它的定义比较繁琐，大多数程序员也许因为这个而不去使用它；同时他还不可以被用作数组下标或是用在switch/case语句。这在一定程度上降低了他的使用的广泛性。
　　
　　看起来，没有一种替代品是理想的。我们虽然没有权利修改Java语言，但是我们也许可以想一些办法来克服"对象枚举"的缺点，使它成为合格的枚举替代品。
　　一个实现枚举的微型语言（ＡMini-Language for Enums）
　　
　　假如我发明一种枚举专用的微型语言（且叫它jEnum），它专门用来申明枚举。然后我再用一个非凡的"翻译"程序将我用这种语言定义的枚举转化为对应的"对象枚举"定义，那不是就解决了"对象枚举"定义复杂的问题了吗。当然我们很轻易让这个"翻译"程序多做一些工作。比如加入Package申明，加入程序注释，说明整数值和该对象的字符串标签名称等等。让我们看下面这样一个例子：
　　
　　package com.softmoore.util;
　　/**
　　* Various USA coins
　　*/
　　enum Coin { PENNY("penny") = 1, NICKEL("nickel") = 5, DIME("dime") = 10,
　　QUARTER("quarter") = 25, HALF_DOLLAR("half dollar") = 50 };
　　
　　虽然"整数常数枚举"在有些情况下优点比较显著。但是总体上讲"对象枚举"提供的类型安全还是更为重要的，相比之下哪些缺点还是比较次要的。下面我们大概讲一下jEnum，使用它我们又可以得到紧凑和有效的枚举申明这一特点，也就是我们前面提到的条件2。
　　
　　熟悉编译器的朋友可能更轻易理解下面这一段jEnum微型语言。
　　
　　compilationUnit = ( packageDecl )？ ( docComment )？ enumTypeDecl .
　　packageDecl = "package" packagePath ";" .
　　packagePath = packageName ( "." packageName )* .
　　docComment = "/**" commentChars "*/" .
　　enumTypeDecl = "enum" enumTypeName "{" enumList "}" ";" .
　　enumList = enumDecl ( "," enumDecl )* .
　　enumDecl = enumLiteral ( "(" stringLiteral ")" )？ ( "=" intLiteral )？ .
　　packageName = identifier .
　　enumTypeName = identifier .
　　enumLiteral = identifier .
　　commentChars = any-char-sequence-except-"*/"
　　
　　这种语法答应在开始申明package，看起来和Java语言还挺像。你可以增加一些javadoc的注解，当然这不是必须的。枚举类型的申明以要害字"enum"开头，枚举的值放在花括号中{}，多个值之间用逗号分开。每一个值的申明包括一个标准的Java变量名，一个可选的字符串标签，可选的等号（=）和一个整数值。
　　
　　假如你省略了字符串标签，那么枚举的变量名就会被使用；假如你省略了等号和后面的整数值，那么它将会自动按顺序给你的枚举赋值，假如没有使用任何数值，那么它从零开始逐步增加（步长为1）。字符串标签作为toString()方法返回值的一部分，而整数值则作为ord()方法的返回值。如下面这段申明：
　　
　　enum Color { RED("Red") = 2, WHITE("White") = 4, BLUE };
　　
　　RED 的标签是 "Red"，值为 2 ；
　　
　　WHITE的标签是"White"，值为4；
　　
　　BLUE的标签是"BLUE" ，值为5 。
　　
　　要注重的是在Java中的保留字在jEnum也是保留的。比如你不可以使用this作为package名，不可以用for为枚举的变量名等等。枚举的变量名和字符串标签必须是不同的，其整数值也必须是严格向上增加的，象下面这段申明就是不对的，因为它的字符串标签不是唯一的。
　　
　　enum Color { RED("Red"), WHITE("BLUE"), BLUE };
　　
　　下面这段申明也是不对的，因为WHITE会被自动赋值2 ，和BLUE有冲突。
　　
　　enum Color { RED = 1, WHITE, BLUE = 2 };
　　
　　下面这是一个具体的实例。它将会被"翻译"程序使用，用以转换成我们枚举申明为可编译的Java源程序。
　　
　　package com.softmoore.jEnum;
　　/**
　　* This class encapsulates the symbols (a.k.a. token types)
　　* of a language token.
　　*/
　　enum Symbol {
　　identifier,
　　enumRW("Reserved Word: enum"),
　　abstractRW("Reserved Word: abstract"),
　　assertRW("Reserved Word: assert"),
　　booleanRW("Reserved Word: boolean"),
　　breakRW("Reserved Word: break"),
　　byteRW("Reserved Word: byte"),
　　caseRW("Reserved Word: case"),
　　catchRW("Reserved Word: catch"),
　　charRW("Reserved Word: char"),
　　classRW("Reserved Word: class"),
　　constRW("Reserved Word: const"),
　　continueRW("Reserved Word: continue"),
　　defaultRW("Reserved Word: default"),
　　doRW("Reserved Word: do"),
　　doubleRW("Reserved Word: double"),
　　elseRW("Reserved Word: else"),
　　extendsRW("Reserved Word: extends"),
　　finalRW("Reserved Word: final"),
　　finallyRW("Reserved Word: finally"),
　　floatRW("Reserved Word: float"),
　　forRW("Reserved Word: for"),
　　gotoRW("Reserved Word: goto"),
　　ifRW("Reserved Word: if"),
　　implementsRW("Reserved Word: implements"),
　　importRW("Reserved Word: import"),
　　instanceOfRW("Reserved Word: instanceOf"),
　　intRW("Reserved Word: int"),
　　interfaceRW("Reserved Word: interface"),
　　longRW("Reserved Word: long"),
　　nativeRW("Reserved Word: native"),
　　newRW("Reserved Word: new"),
　　nullRW("Reserved Word: null"),
　　packageRW("Reserved Word: package"),
　　privateRW("Reserved Word: private"),
　　protectedRW("Reserved Word: protected"),
　　publicRW("Reserved Word: public"),
　　returnRW("Reserved Word: return"),
　　shortRW("Reserved Word: short"),
　　staticRW("Reserved Word: static"),
　　strictfpRW("Reserved Word: strictfp"),
　　superRW("Reserved Word: super"),
　　switchRW("Reserved Word: switch"),
　　synchronizedRW("Reserved Word: synchronized"),
　　thisRW("Reserved Word: this"),
　　throwRW("Reserved Word: throw"),
　　throwsRW("Reserved Word: throws"),
　　transientRW("Reserved Word: transient"),
　　tryRW("Reserved Word: try"),
　　voidRW("Reserved Word: void"),
　　volatileRW("Reserved Word: volatile"),
　　whileRW("Reserved Word: while"),
　　equals("="),
　　leFTParen("("),
　　rightParen(")"),
　　leftBrace(""),
　　comma(","),
　　semicolon(";"),
　　period("."),
　　intLiteral,
　　stringLiteral,
　　docComment,
　　EOF,
　　unknown
　　};
　　
　　假如对Day的枚举申明存放在Day.enum文件中，那么我们可以将这个文件翻译成Java源程序。
　　
　　$ java -jar jEnum.jar Day.enum
　　
　　翻译的结果就是Day.javaJava源程序，内容和我们前面讲的一样，还包括程序注释等内容。假如想省一点事，你可以将上面比较长的命令写成一个批处理文件或是Unix，Linux上的shell script，那么以后使用的时候就可以简单一些，比如：
　　
　　$ jec Day.enum
　　
　　关于jEnum有四点注重事项要说明一下。
　　
　　1． 申明文件名不一定后缀为".enum."，其它合法文件后缀都可以。
　　
　　2． 假如文件后缀不是".enum."，那么翻译程序将首先按给出的文件名去搜索，假如没有，就假定给出的文件名是省略了".enum."后缀的。像这种命令是可以的：
　　
　　$ java -jar jEnum.jar Day
　　
　　3． 生成的Java源程序文件名是按照申明文件内的定义得出的，而不是依据申明文件的名称。
　　
　　4． 翻译程序还接受以下几个开关
　　
　　-o 生成"对象枚举"类枚举，是缺省值
　　
　　-c 生成"整数常数枚举"类枚举，用类来实现
　　
　　-i 生成"整数常数枚举"类枚举，用接口来实现
　　
　　要注重的是，-C开关虽然生成"整数常数枚举"，但它同时还提供了一些"对象枚举"中所具有的方法，如first()， last()，toString(int n)，prev(int n)， 和next(int n)。
　　
　　jEnum工具可以从网上自由下载，其地址是：http://www.onjava.com/onjava/2003/04/23/examples/jEnum.zip