【IT168技术文档】
清单 1. 枚举类型的例子
枚举集合的作用类似于特性的集合，或者类似于某个枚举类型的所有元素的值的子集。EnumSet 类拥有以下一系列的静态方法，可以用这些方法从枚举类型中获取单个元素：
深入研究枚举类型
基础知识
在J2SE中通过使用新的 enum 关键字创建指定的对象集合，您可以创建一个枚举类型。然后，可以将每个指定的值看作是那个类的一个实例，这为您提供了指定的整数集合所无法提供的编译时类型安全。清单 1 将创建一个枚举类型，并将类型安全的枚举值作为帮助器方法（helper method）的参数。该枚举类型的 values() 方法返回这种类型的不同值的有序数组。
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 中所示的构造函数调用中：
new Enum<Size>("Small", 0);
new Enum<Size>("Medium", 1);
new Enum<Size>("Large", 2);
不必将构造函数的使用限制为间接 Enum 构造函数调用。在使用 enum 关键字时，将创建 Enum 的子类。您可以使用参数和任何别的东西为定义的每个名称添加一些您自己的构造函数调用。名称声明可以看作是对构造函数的调用，您不必添加 new 关键字。这种方法允许您将数据作为参数值传递给构造函数调用，如清单 3 所示。该参数表示 Size 对象的枚举集合的定价因子。位于枚举类型定义之后的 main() 方法演示了这种用法。
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 给前面的例子添加了一个方法：
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
预定义的方法
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。
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 类的用法。在创建映射时，必须为枚举的键传入这个类。
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);
}
}
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 变量的类中做这些更有意义吗？
0
相关文章
关注我们
