驯服Tiger之深入研究枚举类型

　　基础知识
　　
　　在J2SE1.5中通过使用新的 enum 关键字创建指定的对象集合，您可以创建一个枚举类型。然后，可以将每个指定的值看作是那个类的一个实例，这为您提供了指定的整数集合所无法提供的编译时类型安全。清单 1 将创建一个枚举类型，并将类型安全的枚举值作为帮助器方法（helper method）的参数。该枚举类型的 values() 方法返回这种类型的不同值的有序数组。
　　
　　清单 1. 枚举类型的例子
　　
　　public class Loop {
　　enum Size {
　　Small,
　　Medium,
　　Large
　　}
　　public static void main(String args[]) {
　　for (Size s : Size.values()) {
　　helper(s);
　　}
　　}
　　
　　private static void helper(Size s) {
　　System.out.println("Size value: " + s);
　　}
　　}
　　
　　构造函数、方法和变量
　　
　　在使用 enum 关键字创建新的枚举类型时，实际上是在创建 java.lang.Enum 类的子类，其中，枚举类型符合通用模式 Class Enum＜E extends Enum＜E＞＞，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了每个设置的优先值。换句话说，enum Size {Small, Medium, Large} 将映射到清单 2 中所示的构造函数调用中：
　　
　　清单 2. 映射的构造函数调用
　　
　　new Enum＜Size＞("Small", 0);
　　new Enum＜Size＞("Medium", 1);
　　new Enum＜Size＞("Large", 2);
　　
　　不必将构造函数的使用限制为间接 Enum 构造函数调用。在使用 enum 关键字时，将创建 Enum 的子类。您可以使用参数和任何别的东西为定义的每个名称添加一些您自己的构造函数调用。名称声明可以看作是对构造函数的调用，您不必添加 new 关键字。这种方法允许您将数据作为参数值传递给构造函数调用，如清单 3 所示。该参数表示 Size 对象的枚举集合的定价因子。位于枚举类型定义之后的 main() 方法演示了这种用法。
　　
　　清单 3. 定制构造函数的例子
　　
　　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. 方法的例子
　　
　　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);
　　}
　　}
　　
　　对于这两种情况，输出均为：
　　
　　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. 特定于常量的主体
　　
　　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 的例子
　　
　　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 对象那样对待这组对象。
　　
　　结束语
　　
　　使用枚举

查看本文来源