Java枚举类型

Java枚举类型入门
这里就将为大家谈谈Java枚举类型，static final通常跟的是一个int类型的常数，所以有时候可以用int型代替枚举。

在Java中，枚举确实是一个类。

Tiger中的一个重要新特性是枚举构造，它是一种新的Java枚举类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。

Tiger 专家、developerWorks 的多产作者Brett McLaughlin将解释枚举的定义，介绍如何在应用程序中运用枚举，以及它为什么能够让您抛弃所有旧的public static final 代码。

您已经知道，Java 代码的两个基本的构造块是类和接口。

现在Tiger 又引入了枚举，一般简称它为enum。

这个新类型允许您表示特定的数据点，这些数据点只接受分配时预先定义的值集合。

当然，熟练的程序员可以用静态常量实现这项功能，如清单 1 所示：清单 1. public static final 的常量
1.public class OldGrade {
2.
3.public static final int A = 1;
4.public static final int B = 2;
5.public static final int C = 3;
6.public static final int D = 4;
7.public static final int F = 5;
8.public static final int INCOMPLETE = 6;
9.}
说明：我要感谢O'Reilly 媒体公司，该公司允许在本文中使用我撰写的Java 1.5 Tiger:A Developer's Notebook 一书中“枚举”这一章中的代码示例（请参阅参考资料）。

然后您就可以让类接受像OldGrade.B 这样的常量，但是在这样做的时候，请记住这类常量是Java 中int 类型的常量，这意味着该方法可以接受任何int 类型的值，即使它和OldGrade 中定的所有级别都不对应。

因此，您需要检测上界和下界，在出现无效值的时候，可能还要包含一个IllegalArgumentException。

而且，如果后来又添加另外一个级别（例如OldGrade.WITHDREW_PASSING），那么必须改变所有代码中的上界，才能接受这个新值。

换句话说，在使用这类带有整型常量的类时，该解决方案也许可行，但并不是非常有效。

幸运的是，枚举提供了更好的方法。

定义枚举清单 2 使用了一个可以提供与清单 1 相似的功能的枚举：
清单 2. 简单的枚举类型
10.package com.oreilly.tiger.ch03;
11.
12.public enum Grade {
13.A, B, C, D, F, INCOMPLETE
14.};
在这里，我使用了新的关键字enum，为enum 提供了一个名称，并指定了允许的值。

然后，Grade 就变成了一个枚举类型，您可以按清单3 所示的方法使用它：
清单 3. 使用枚举类型
15.package com.oreilly.tiger.ch03;
16.
17.public class Student {
18.
19.private String firstName;
20.private String lastName;
21.private Grade grade;
22.
23.public Student(String firstName, String lastName) {
24.this.firstName = firstName;
stName = lastName;
26.}
27.
28.public void setFirstName(String firstName) {
29.this.firstName = firstName;
30.}
31.
32.public String getFirstName() {
33.return firstName;
34.}
35.
36.public void setLastName(String lastName) {
stName = lastName;
38.}
39.
40.public String getLastName() {
41.return lastName;
42.}
43.
44.public String getFullName() {
45.return new StringBuffer(firstName)
46..append(" ")
47..append(lastName)
48..toString();
49.}
50.
51.public void assignGrade(Grade grade) {
52.this.grade = grade;
53.}
54.
55.public Grade getGrade() {
56.return grade;
57.}
58.}
用以前定义过的类型建立一个新的枚举（grade）之后，您就可以像使用其他成员变量一样使用它了。

当然，枚举只能分配枚举值中的一个（例如，A、C 或INCOMPLETE）。

而且，在assignGrade() 中是没有进行错误检测的代码，也没有考虑边界情况，请注意这是如何做到。

使用Java枚举值
迄今为止，您所看到的示例都相当简单，但是枚举类型提供的东西远不止这些。

您可以逐个遍历枚举值，也可以在switch 语句中使用枚举值，枚举是非常有价值的。

遍历Java枚举值
下面我们用一个示例显示如何遍历枚举类型的值。

清单 4 所示的这项技术，适用于调试、快速打印任务以及把枚举加载到集合（我很快将谈到）中的工具：
清单 4. 遍历枚举值
59.public void listGradeValues(PrintStream out) throws IOException {
60.for (Grade g : Grade.values()) {
61.out.println("Allowed value: '" + g + "'");
62.}
63.}
运行这段代码，将得到清单 5 所示的输出：
清单 5. 迭代操作的输出
64.Allowed Value: 'A'
65.Allowed Value: 'B'
66.Allowed Value: 'C'
67.Allowed Value: 'D'
68.Allowed Value: 'F'
69.Allowed Value: 'INCOMPLETE'
这里有许多东西。

首先，我使用了Tiger 的新的for/in 循环（也叫作foreach 或增强的for）。

另外，您可以看到values() 方法返回了一个由独立的Grade 实例构成的数组，每个数组都有一个枚举类型的值。

换句话说，values() 的返回值是Grade[]。

在枚举间切换
能够在枚举的值之间移动很好，但是更重要的是根据枚举的值进行决策。

您当然可以写一堆if (grade.equals(Grade.A)) 类型的语句，但那是在浪费时间。

Tiger 能够很方便地把枚举支持添加到过去的好东西switch 语句上，所以它很容易使用，而且适合您已知的内容。

清单6向将展示如何解决这个难题：
清单 6. 在枚举之间切换
70.public void testSwitchStatement(PrintStream out) throws IOException {
71.StringBuffer outputText = new StringBuffer(student1.getFullName());
72.
73.switch (student1.getGrade()) {
74.case A:
75.outputText.append(" excelled with a grade of A");
76.break;
77.case B: // fall through to C
78.case C:
79.outputText.append(" passed with a grade of ")
80..append(student1.getGrade().toString());
81.break;
82.case D: // fall through to F
83.case F:
84.outputText.append(" failed with a grade of ")
85..append(student1.getGrade().toString());
86.break;
87.case INCOMPLETE:
88.outputText.append(" did not complete the class.");
89.break;
90.}
91.
92.out.println(outputText.toString());
93.}
在这里，枚举值被传递到switch 语句中（请记住，getGrade() 是作为Grade 的实例返回的），而每个case 子句将处理一个特定的值。

该值在提供时没有枚举前缀，这意味着不用将代码写成case Grade.A，只需将其写成case A 即可。

如果您不这么做，编译器不会接受有前缀的值。

现在，您应该已经了解使用switch 语句时的基本语法，但是还有一些事情您需要知道。

在使用switch 之前进行计划正如您所期待的，在使用枚举和switch 时，您可以使用default 语句。

清单7 显示了这个用法:
清单7. 添加一个default 块
94.public void testSwitchStatement(PrintStream out) throws IOException {
95.StringBuffer outputText = new StringBuffer(student1.getFullName());
96.
97.switch (student1.getGrade()) {
98.case A:
99.outputText.append(" excelled with a grade of A");
100.break;
101.case B: // fall through to C
102.case C:
103.outputText.append(" passed with a grade of ")
104..append(student1.getGrade().toString());
105.break;
106.case D: // fall through to F
107.case F:
108.outputText.append(" failed with a grade of ")
109..append(student1.getGrade().toString());
110.break;
111.case INCOMPLETE:
112.outputText.append(" did not complete the class.");
113.break;
114.default:
115.outputText.append(" has a grade of ")
116..append(student1.getGrade().toString());
117.break;
118.}
119.
120.out.println(outputText.toString());
121.}
研究以上代码可以看出，任何没有被case 语句处理的枚举值都会被default 语句处理。

这项技术您应当坚持采用。

原因是：假设Grade 枚举被您的小组中其他程序员修改（而且他忘记告诉您这件事）成清单8 所示的版本：
清单8. 给Grade 枚举添加一个值
122.package com.oreilly.tiger.ch03;
123.
124.public enum Grade {
125.A, B, C, D, F, INCOMPLETE,
126.WITHDREW_PASSING, WITHDREW_FAILING
127.};
现在，如果使用清单6 的代码所示的新版Grade，那么这两个新值会被忽略。

更糟的是，您甚至看不到错误！在这种情况下，存在某种能够通用的default 语句是非常重要的。

清单7 无法很好地处理这些值，但是它会提示您还有其他值，您需要处理这些值。

一旦完成处理，您就会有一个继续运行的应用程序，而且它不会忽略这些值，甚至还会指导您下一步的动作。

所以这是一个良好的编码习惯。

枚举和集合您所熟悉的使用public static final 方法进行编码的那些东西，可能已经转而采用枚举的值作为映射的键。

如果您不知道其中的含义，请参见清单9，它是一个公共错误信息的示例，在使用Ant 的build 文件时，可能会弹出这样的消息，如下所示：清单9. Ant 状态码
128.package com.oreilly.tiger.ch03;
129.
130.public enum AntStatus {
131.INITIALIZING,
PILING,
133.COPYING,
134.JARRING,
135.ZIPPING,
136.DONE,
137.ERROR
138.}
为每个状态码分配一些人们能读懂的错误信息，从而允许人们在Ant 提供某个代码时查找合适的错误信息，将这些信息显示在控制台上。

这是映射（Map）的一个绝好用例，在这里，每个映射（Map）的键都是一个枚举值，而每个值都是键的错误信息。

清单10 演示了该映射的工作方式：
清单10. 枚举的映射（Map）
139.public void testEnumMap(PrintStream out) throws IOException {
140.// Create a map with the key and a String message
141.EnumMap antMessages =
142.new EnumMap(AntStatus.class);
143.
144.// Initialize the map
145.antMessages.put(AntStatus.INITIALIZING, "Initializing Ant...");
146.antMessages.put(PILING, "Compiling Java classes...");
147.antMessages.put(AntStatus.COPYING, "Copying files...");
148.antMessages.put(AntStatus.JARRING, "JARring up files...");
149.antMessages.put(AntStatus.ZIPPING, "ZIPping up files...");
150.antMessages.put(AntStatus.DONE, "Build complete.");
151.antMessages.put(AntStatus.ERROR, "Error occurred.");
152.
153.// Iterate and print messages
154.for (AntStatus status : AntStatus.values() ) {
155.out.println("For status " + status + ", message is: " +
156.antMessages.get(status));
157.}
158.}
该代码使用了泛型（generics）（请参阅参考资料）和新的EnumMap 构造来建立新映射。

而且，枚举值是通过其Class 对象提供的，同时提供的还有映射值的类型（在该例中，它只是一个简单的字符串）。

该方法的输出如清单11 所示：
Java枚举类型中的Class 对象您可能已经注意到，清单10 中的示例代码实际上表明Tiger 把枚举当作类，这可以从AntStatus 的Class 对象那里得到证明，该对象不仅可用，而且正被实际使用。

这是真的。

归根到底, Tiger 还是把枚举看成是特殊的类类型。

有关枚举的具体实现细节，请参阅Java 5.0 Tiger: A Developer's Notebook 的第三章（请参阅参考资料）。

清单11. 清单10 的输出
159.[echo] Running AntStatusTester...
160.[java] For status INITIALIZING, message is: Initializing Ant...
161.[java] For status COMPILING, message is: Compiling Java classes...
162.[java] For status COPYING, message is: Copying files...
163.[java] For status JARRING, message is: JARring up files...
164.[java] For status ZIPPING, message is: ZIPping up files...
165.[java] For status DONE, message is: Build complete.
166.[java] For status ERROR, message is: Error occurred.
更进一步枚举也可以与集合结合使用，而且非常像新的EnumMap 构造，Tiger 提供了一套新的EnumSet实现，允许您使用位操作符。

另外，可以为枚举添加方法，用它们实现接口，定义叫作特定值的类的实体，在该实体中，特定的代码被附加到枚举的具体值上。

这些特性超出了本文的范围，但是在其他地方，有详细介绍它们的文档（请参阅参考资料）。

使用Java枚举类型，但是不要滥用
学习任何新版语言的一个危险就是疯狂使用新的语法结构。

如果这样做，那么您的代码就会突然之间有80% 是泛型、标注和枚举。

所以，应当只在适合使用枚举的地方才使用它。

那么，枚举在什么地方适用呢？一条普遍规则是，任何使用常量的地方，例如目前用switch 代码切换常量的地方。

如果只有单独一个值（例如，鞋的最大尺寸，或者笼子中能装猴子的最大数目），则还是把这个任务留给常量吧。

但是，如果定义了一组值，而这些值中的任何一个都可以用于特定的数据类型，那么将枚举用在这个地方最适合不过。