深入研究枚举类型

枚举类型入门

代码：https://github.com/singgel/eight-sorting-algorithms/tree/master/src/test/java/com/hks/eightsortingalgorithms/enumClass

您已经知道，Java 代码的两个基本的构造块是 类和 接口。现在 Tiger 又引入了 枚举，一般简称它为enum。这个新类型允许您表示特定的数据点，这些数据点只接受分配时预先定义的值集合。

当然，熟练的程序员可以用静态常量实现这项功能，如清单 1 所示：

清单 1. public static final 的常量

1 2 3 4 5 6 7 8

public class OldGrade {   public static final int A = 1;   public static final int B = 2;   public static final int C = 3;   public static final int D = 4;   public static final int F = 5;   public static final int INCOMPLETE = 6; }

然后您就可以让类接受像 OldGrade.B 这样的常量，但是在这样做的时候，请记住这类常量是 Java 中int 类型的常量，这意味着该方法可以接受任何 int 类型的值，即使它和 OldGrade 中定义的所有级别都不对应。因此，您需要检测上界和下界，在出现无效值的时候，可能还要包含一个IllegalArgumentException 。而且，如果后来又添加另外一个级别（例如OldGrade.WITHDREW_PASSING ），那么必须改变所有代码中的上界，才能接受这个新值。

换句话说，在使用这类带有整型常量的类时，该解决方案也许可行，但并不是非常有效。幸运的是，枚举提供了更好的方法。

定义枚举

清单 2 使用了一个可以提供与清单 1 相似的功能的枚举：

清单 2. 简单的枚举类型

1 2 3 4

package com.oreilly.tiger.ch03; public enum Grade {   A, B, C, D, F, INCOMPLETE };

在这里，我使用了新的关键字 enum ，为 enum 提供了一个名称，并指定了允许的值。然后， Grade 就变成了一个 枚举类型，您可以按清单 3 所示的方法使用它：

清单 3. 使用枚举类型

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

package com.oreilly.tiger.ch03; public class Student {   private String firstName;   private String lastName;   private Grade grade;   public Student(String firstName, String lastName) {     this.firstName = firstName;     this.lastName = lastName;   }   public void setFirstName(String firstName) {     this.firstName = firstName;   }   public String getFirstName() {     return firstName;   }   public void setLastName(String lastName) {     this.lastName = lastName;   }   public String getLastName() {     return lastName;   }   public String getFullName() {     return new StringBuffer(firstName)            .append(" ")            .append(lastName)            .toString();   }   public void assignGrade(Grade grade) {     this.grade = grade;   }   public Grade getGrade() {     return grade;   } }

用以前定义过的类型建立一个新的枚举（ grade ）之后，您就可以像使用其他成员变量一样使用它了。当然，枚举只能分配枚举值中的一个（例如， A 、 C 或 INCOMPLETE ）。而且，在 assignGrade() 中是没有进行错误检测的代码，也没有考虑边界情况，请注意这是如何做到。

使用枚举值

迄今为止，您所看到的示例都相当简单，但是枚举类型提供的东西远不止这些。您可以逐个遍历枚举值，也可以在 switch 语句中使用枚举值，枚举是非常有价值的。

遍历枚举值

下面我们用一个示例显示如何遍历枚举类型的值。清单 4 所示的这项技术，适用于调试、快速打印任务以及把枚举加载到集合（我很快将谈到）中的工具：

清单 4. 遍历枚举值

1 2 3 4 5

public void listGradeValues(PrintStream out) throws IOException {   for (Grade g : Grade.values()) {     out.println("Allowed value: '" + g + "'");   } }

运行这段代码，将得到清单 5 所示的输出：

清单 5. 迭代操作的输出

1 2 3 4 5 6

Allowed Value: 'A' Allowed Value: 'B' Allowed Value: 'C' Allowed Value: 'D' Allowed Value: 'F' Allowed Value: 'INCOMPLETE'

这里有许多东西。首先，我使用了 Tiger 的新的 for/in 循环（也叫作 foreach 或 增强的 for ）。另外，您可以看到 values() 方法返回了一个由独立的 Grade 实例构成的数组，每个数组都有一个枚举类型的值。换句话说， values() 的返回值是 Grade[] 。

在枚举间切换

能够在枚举的值之间移动很好，但是更重要的是根据枚举的值进行决策。您当然可以写一堆 if (grade.equals(Grade.A)) 类型的语句，但那是在浪费时间。Tiger 能够很方便地把枚举支持添加到过去的好东西 switch 语句上，所以它很容易使用，而且适合您已知的内容。清单 6 向将展示如何解决这个难题：

清单 6. 在枚举之间切换

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public void testSwitchStatement(PrintStream out) throws IOException {   StringBuffer outputText = new StringBuffer(student1.getFullName());   switch (student1.getGrade()) {     case A:       outputText.append(" excelled with a grade of A");       break;       case B: // fall through to C     case C:       outputText.append(" passed with a grade of ")                 .append(student1.getGrade().toString());       break;     case D: // fall through to F     case F:       outputText.append(" failed with a grade of ")                 .append(student1.getGrade().toString());       break;     case INCOMPLETE:       outputText.append(" did not complete the class.");       break;   }   out.println(outputText.toString()); }

在这里，枚举值被传递到 switch 语句中（请记住， getGrade() 是作为 Grade 的实例返回的），而每个case 子句将处理一个特定的值。该值在提供时没有枚举前缀，这意味着不用将代码写成 case Grade.A，只需将其写成 case A 即可。如果您不这么做，编译器不会接受有前缀的值。

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

在使用 switch 之前进行计划

正如您所期待的，在使用枚举和 switch 时，您可以使用 default 语句。清单 7 显示了这个用法:

清单 7. 添加一个 default 块

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public void testSwitchStatement(PrintStream out) throws IOException {   StringBuffer outputText = new StringBuffer(student1.getFullName());   switch (student1.getGrade()) {     case A:       outputText.append(" excelled with a grade of A");       break;       case B: // fall through to C     case C:       outputText.append(" passed with a grade of ")                 .append(student1.getGrade().toString());       break;     case D: // fall through to F     case F:       outputText.append(" failed with a grade of ")                 .append(student1.getGrade().toString());       break;     case INCOMPLETE:       outputText.append(" did not complete the class.");       break;               default:       outputText.append(" has a grade of ")                 .append(student1.getGrade().toString());       break;   }   out.println(outputText.toString()); }

研究以上代码可以看出，任何没有被 case 语句处理的枚举值都会被 default 语句处理。这项技术您应当坚持采用。原因是：假设 Grade 枚举被您的小组中其他程序员修改（而且他忘记告诉您这件事）成清单 8 所示的版本：

清单 8. 给 Grade 枚举添加一个值

1 2 3 4 5 6

package com.oreilly.tiger.ch03; public enum Grade {   A, B, C, D, F, INCOMPLETE         ,   WITHDREW_PASSING, WITHDREW_FAILING };

现在，如果使用清单 6 的代码所示的新版 Grade ，那么这两个新值会被忽略。更糟的是，您甚至看不到错误！在这种情况下，存在某种能够通用的 default 语句是非常重要的。清单 7 无法很好地处理这些值，但是它会提示您还有其他值，您需要处理这些值。一旦完成处理，您就会有一个继续运行的应用程序，而且它不会忽略这些值，甚至还会指导您下一步的动作。所以这是一个良好的编码习惯。

枚举和集合

您所熟悉的使用 public static final 方法进行编码的那些东西，可能已经转而采用枚举的值作为映射的键。如果您不知道其中的含义，请参见清单 9，它是一个公共错误信息的示例，在使用 Ant 的 build 文件时，可能会弹出这样的消息，如下所示：

清单 9. Ant 状态码

1 2 3 4 5 6 7 8 9 10

package com.oreilly.tiger.ch03; public enum AntStatus {   INITIALIZING,   COMPILING,   COPYING,   JARRING,   ZIPPING,   DONE,   ERROR }

为每个状态码分配一些人们能读懂的错误信息，从而允许人们在 Ant 提供某个代码时查找合适的错误信息，将这些信息显示在控制台上。这是 映射（Map） 的一个绝好用例，在这里，每个 映射（Map） 的键都是一个枚举值，而每个值都是键的错误信息。清单 10 演示了该映射的工作方式：

清单 10. 枚举的映射（Map）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public void testEnumMap(PrintStream out) throws IOException {   // Create a map with the key and a String message   EnumMap<AntStatus, String> antMessages =     new EnumMap<AntStatus, String>(AntStatus.class);   // Initialize the map   antMessages.put(AntStatus.INITIALIZING, "Initializing Ant...");   antMessages.put(AntStatus.COMPILING,    "Compiling Java classes...");   antMessages.put(AntStatus.COPYING,      "Copying files...");   antMessages.put(AntStatus.JARRING,      "JARring up files...");   antMessages.put(AntStatus.ZIPPING,      "ZIPping up files...");   antMessages.put(AntStatus.DONE,         "Build complete.");   antMessages.put(AntStatus.ERROR,        "Error occurred.");   // Iterate and print messages   for (AntStatus status : AntStatus.values() ) {     out.println("For status " + status + ", message is: " +                 antMessages.get(status));   } }

该代码使用了泛型（generics）（请参阅 参考资料）和新的 EnumMap 构造来建立新映射。而且，枚举值是通过其 Class 对象提供的，同时提供的还有映射值的类型（在该例中，它只是一个简单的字符串）。该方法的输出如清单 11 所示：

枚举的 Class 对象？

您可能已经注意到，清单 10 中的示例代码实际上表明 Tiger 把枚举当作类，这可以从AntStatus 的 Class 对象那里得到证明，该对象不仅可用，而且正被实际使用。这是真的。归根到底, Tiger 还是把枚举看成是特殊的类类型。有关枚举的具体实现细节，请参阅 Java 5.0 Tiger: A Developer's Notebook的第三章（请参阅 参考资料）。

清单 11. 清单 10 的输出

1 2 3 4 5 6 7 8

[echo] Running AntStatusTester... [java] For status INITIALIZING, message is: Initializing Ant... [java] For status COMPILING, message is: Compiling Java classes... [java] For status COPYING, message is: Copying files... [java] For status JARRING, message is: JARring up files... [java] For status ZIPPING, message is: ZIPping up files... [java] For status DONE, message is: Build complete. [java] For status ERROR, message is: Error occurred.

更进一步

枚举也可以与集合结合使用，而且非常像新的 EnumMap 构造，Tiger 提供了一套新的 EnumSet 实现，允许您使用位操作符。另外，可以为枚举添加方法，用它们实现接口，定义叫作 特定值的类的实体，在该实体中，特定的代码被附加到枚举的具体值上。这些特性超出了本文的范围，但是在其他地方，有详细介绍它们的文档（请参阅 参考资料）。

使用枚举，但是不要滥用

学习任何新版语言的一个危险就是疯狂使用新的语法结构。如果这样做，那么您的代码就会突然之间有 80% 是泛型、标注和枚举。所以，应当只在适合使用枚举的地方才使用它。那么，枚举在什么地方适用呢？一条普遍规则是，任何使用常量的地方，例如目前用 switch 代码切换常量的地方。如果只有单独一个值（例如，鞋的最大尺寸，或者笼子中能装猴子的最大数目），则还是把这个任务留给常量吧。但是，如果定义了一组值，而这些值中的任何一个都可以用于特定的数据类型，那么将枚举用在这个地方最适合不过。

构造函数、方法和变量

在使用 enum 关键字创建新的枚举类型时，实际上是在创建 java.lang.Enum 类的子类，其中，枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了每个设置的优先值。换句话说，enum Size {Small, Medium, Large} 将映射到清单 2 中所示的构造函数调用中：

清单 2. 映射的构造函数调用

1 2 3

new Enum<Size>("Small", 0); new Enum<Size>("Medium", 1); new Enum<Size>("Large", 2);

不必将构造函数的使用限制为间接 Enum 构造函数调用。在使用 enum 关键字时，将创建 Enum 的子类。您可以使用参数和任何别的东西为定义的每个名称添加一些您自己的构造函数调用。名称声明可以看作是对构造函数的调用，您不必添加 new 关键字。这种方法允许您将数据作为参数值传递给构造函数调用，如清单 3 所示。该参数表示 Size 对象的枚举集合的定价因子。位于枚举类型定义之后的 main() 方法演示了这种用法。

清单 3. 定制构造函数的例子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Sample {   enum Size {     Small(0.8),     Medium(1.0),     Large(1.2);     double pricingFactor;     Size(double p) {       pricingFactor = p;     }   }   public static void main(String args[]) {     Size s = Size.Large;     double d = s.pricingFactor;     System.out.println(s + " Size has pricing factor of " + d);   } }

运行该程序将返回给定 Size 的定价因子。您还可以定义一个类似于 getPricingFactor() 的方法，并将 pricingFactor 字段设置为 private，以便更多地将它作为类 JavaBean 的属性对待。清单 4 给前面的例子添加了一个方法：

清单 4. 方法的例子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Sample2 {   enum Size {     Small(0.8),     Medium(1.0),     Large(1.2);     private double pricingFactor;     Size(double p) {       pricingFactor = p;     }     public double getPricingFactor() {       return pricingFactor;     }   }   public static void main(String args[]) {     Size s = Size.Large;     double d = s.getPricingFactor();     System.out.println(s + " Size has pricing factor of " + d);   } }

对于这两种情况，输出均为：

1	Large Size has pricing factor of 1.2

预定义的方法

因为用户定义的枚举类型是 Enum 类型的子类，所以您需要继承用于您的类型的那个类的所有方法。下面列出了完整的方法集合（E 表示枚举类型自身）：

• public int compareTo(E e)
• public boolean equals(Object o)
• public final Class<E> getDeclaringClass()
• public int hashCode()
• public String name()
• public int ordinal()
• public String toString()
• public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)

一些方法看起来很熟悉，而其他一些方法则是特定于 Enum 类的。compareTo()、equals() 和 hashCode() 方法是典型的 Object 和 Comparable 方法，其中，compareTo() 报告声明元素的顺序。name() 和 ordinal() 方法返回构造函数参数，而 toString() 返回名称。

getDeclaringClass() 和 valueOf() 方法需要稍多一些解释。getDeclaringClass() 方法类似于 Object 的 getClass() 方法，但它没必要返回相同的类。根据这个方法的 Javadoc 的说明：

对于具有特定于常量的类主体的 enum 常量，该方法返回的值可能不同于  Object.getClass() 方法返回的值。

接下来，我将解释特定于常量的类主体。valueOf() 方法是静态的，它允许您从类型的名称中创建枚举的值。

特定于常量的类主体

特定于常量的类主体是 enum 关键字的一个受支持的特性；不过，它们的使用应该受到严格的限制。这个概念正在深入到将枚举类型的每个元素作为一个子类对待的领域。例如，在前面的例子中，Size 枚举类型有一个定价因子参数和 getPricingFactor() 方法。但没有构造函数参数，清单 5 展示了如何利用特定于常量的主体来做同样的事。我们添加了一些额外的大小来让这个例子更有趣些。在这里，Small 的定价因子是 0.8，而 ExtraLarge 和 ExtraExtraLarge 的定价因子是 1.2。其余的大小则采用默认值，即 1.0。

清单 5. 特定于常量的主体

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public class Sample3 {   enum Size {     Small {       public double getPricingFactor() {         return 0.8;       }     },     Medium,     Large,     ExtraLarge {       public double getPricingFactor() {         return 1.2;       }     },     ExtraExtraLarge {       public double getPricingFactor() {         return 1.2;       }     };     public double getPricingFactor() {       return 1.0;     }   }   public static void main(String args[]) {     for (Size s : Size.values()) {       double d = s.getPricingFactor();       System.out.println(s + " Size has pricing factor of " + d);     }   } }

如果回头想想前面描述过的 getDeclaringClass() 方法，您就能明白为什么这些特定于常量的主体和 getClass() 能够在拥有特定于常量的类主体的同时返回不同的类。

EnumMap 和 EnumSet

java.util 程序包中包含两个类：EnumMap 和 EnumSet，这两个类有助于使处理枚举类型变得更容易一些。EnumMap 类提供了 java.util.Map 接口的一个特殊实现，该接口中的键（key）是一个枚举类型。EnumSet 类提供了 java.util.Set 接口的实现，该接口保存了某种枚举类型的值的集合。

清单 6 展示了 EnumMap 类的用法。在创建映射时，必须为枚举的键传入这个类。

清单 6. EnumMap 的例子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import java.util.*; public class EnumMapSample {   enum Size {     Small,     Medium,     Large;   }   public static void main(String args[]) {     Map<Size, Double> map = new EnumMap<Size, Double>(Size.class);     map.put(Size.Small, 0.8);     map.put(Size.Medium, 1.0);     map.put(Size.Large, 1.2);     for (Map.Entry<Size, Double> entry : map.entrySet()) {       helper(entry);     }   }   private static void helper(Map.Entry<Size, Double> entry) {     System.out.println("Map entry: " + entry);   } }

枚举集合的作用类似于特性的集合，或者类似于某个枚举类型的所有元素的值的子集。EnumSet 类拥有以下一系列的静态方法，可以用这些方法从枚举类型中获取单个元素：

• public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType)
• public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s)
• public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)
• public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType)
• public static <E extends Enum<E>> EnumSet<E> of(E e)
• public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest)
• public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)
• public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3)
• public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4)
• public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4, E e5)
• public static <E extends Enum<E>> EnumSet<E> range(E from, E to)

一旦创建了 EnumSet，就可以像对待其他任何 Set 对象那样对待这组对象。

结束语

使用枚举类型的基本概念很简单。您可以先定义一个指定的、封闭的值集合。然后，在需要这些值中的某一个值时，可以通过它的名称来指定它。该名称携带为其设置的类型。对于不同的大小，不是说 1 = Small, 2 = Medium, 3 = Large，并且确保没有将 1 = Monday 的这类东西传递给期望获得一个 Size的方法，而是传入 Small、Medium 或 Large 作为 Size，因为编译器会确保您没有传入 Monday。这就是枚举类型的简单性。这些枚举类型就是类本身，因此，可以对类进行的所有操作同样可以作用于枚举类型上。

此外，枚举类型支持拥有构造函数、实例方法和变量，等等。应该对枚举类型使用这些方面吗？尽管使用这些方法和新的支持类肯定没问题，但提供构造函数和覆盖方法会有问题。说出为枚举中的每个 Size所支付的价格真的有意义吗？或者说，在一个拥有枚举类型 Size 变量的类中做这些更有意义吗？

小心使用这些特性，不要因为这些特性可用就使用它们。要考虑到系统的总体设计，不要只图快点完成工作。