Java1.5 中出现了枚举类型。当一个值都在一个固定的范围内变化，那就可以使用 enum 类型来定义。比如说，一周有七天，一年有四季。
没有枚举类的时候，我们用常量来定义一组范围值的：
public static class Season {
public static final int SPRING = 1;
public static final int SUMMER = 2;
public static final int AUTUMN = 3;
public static final int WINTER = 4;
}
通过常量定义的方式有这样几个缺点：
-
类型不安全。如
Season类所示，程序执行过程中接收的是任意一个int类型的值，完全可能传入一个 1 到 4 之外的值，导致错误的出现。 -
一致性差。int 枚举属于编译期常量，编译完成后，代码中引用的地方会直接将整数值写入。也就是说，该 Int 枚举被修改之后，所有引用它的程序都需要重新编译。
-
类型无指意性。Seaon 枚举值仅仅是一些无任何含义的整数值，调试期间仅仅是一些魔数。
定义一个 enum
《阿里巴巴Java开发手册（华山版）》中建议我们这样定义一个 enum 类：
【参考】枚举类名带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开。
说明：枚举其实就是特殊的类，域成员均为常量，且构造方法被默认强制是私有。
正例：枚举名字为 ProcessStatusEnum 的成员名称：SUCCESS / UNKNOWN_REASON。
【推荐】如果变量值仅在一个固定范围内变化用 enum 类型来定义。
说明：如果存在名称之外的延伸属性应使用 enum 类型，下面正例中的数字就是延伸信息，表示一年中的第几个季节。
由此，我们可以定义一个季节的枚举类，如下所示：
public enum SeasonEnum {
SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);
private int seq;
SeasonEnum(int seq) {
this.seq = seq;
}
public int getSeq() {
return seq;
}
}
enum 类
使用 enum 定义的枚举类默认继承 java.lang.Enum ：
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable {
...
}
变量
// enum 实例的名字
private final String name;
// 定义enum实例的顺序，从0开始计数
private final int ordinal;
方法
// 返回enum实例的名称，eg. SeasonEnum.SPRING.name() - output: SPRING
public final String name() { return name;}
// 返回enum实例的顺序，eg. SeasonEnum.SPRING.ordinal() - output: 0
public final int ordinal() { return ordinal;}
// enum实例 -> 字符串 eg. SeasonEnum.SPRING.toString() - output: SPRING
public String toString() { return name;}
// 比较是不是一个constant，即两个enum实例的顺序(oridnal)是否相同
public final int compareTo(E o) { ... return self.ordinal - other.ordinal; }
// 比较是不是同一个对象
public final boolean equals(Object other) { return this==other;}
// 返回声明枚举常量的类的类对象
public final Class<E> getDeclaringClass(){...}
// 返回指定name的enum实例
public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {}
// values()是编译器产生的一个方法，API中没有，可以用来遍历
public static SeasonEnum getSeasonByOrdinal(int seq) {
for (SeasonEnum season: SeasonEnum.values()) {
if(season.getSeq() == seq) {
return season;
}
}
return null;
}
enum 的用法
用法一：定义常量
也就是最开始说的，enum 出现之后，用 enum 来代替常量类型。
public static class Season {
public static final int SPRING = 1;
public static final int SUMMER = 2;
public static final int AUTUMN = 3;
public static final int WINTER = 4;
}
public enum SeasonEnum {
SPRING, SUMMER, AUTUMN, WINTER;
}
用法二：switch
Java1.5 推出了 enum，Java1.6 支持在 switch 中使用 enum 类型。
public enum OperationUseSwitch {
PLUS, MINUS, TIMES, DIVIDE;
double apply(double x, double y) {
switch (this) {
case PLUS:
return x + y;
case MINUS:
return x - y;
case TIMES:
return x * y;
case DIVIDE:
return x / y;
}
// 如果this不属于上面四种操作符，抛出异常
throw new AssertionError("Unknown operation: " + this);
}
}
用法三：特定于常量的方法实现
特定于常量的方法实现指的是，在 enum 类中定义一个抽象方法，然后各个枚举常量需要实现这个方法。这样做的优点在于，相对于 switch 语句，抽象程度更高，每个 enum 实例都需要实现统一的方法，不会漏下。
public enum Operation {
PLUS {
double apply(double x, double y) {
return x + y;
}
},
MINUS {
double apply(double x, double y) {
return x - y;
}
},
TIMES {
double apply(double x, double y) {
return x * y;
}
},
DIVIDE {
double apply(double x, double y) {
return x / y;
}
};
abstract double apply(double x, double y);
}
用法四：实现接口
enum 类都隐式得继承自 java.lang.Enum，而 Java 只支持单继承，所有 enum 类不能再继承其它类，但是可以实现接口。比如用法三中将统一的方法抽象出来，就可以使用接口来实现：
public interface Behavior {
double apply(double x, double y);
}
public enum Operation implements Behavior{
PLUS {
public double apply(double x, double y) {
return x + y;
}
},
MINUS {
public double apply(double x, double y) {
return x - y;
}
},
TIMES {
public double apply(double x, double y) {
return x * y;
}
},
DIVIDE {
public double apply(double x, double y) {
return x / y;
}
};
}
用法五：覆盖 Enum 的方法
public class Test {
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 覆盖方法
@Override
public String toString() {
return this.index + "_" + this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
EnumSet 和 EnumMap
EnumSet 和 EnumMap 是两个为枚举而设计的集合。EnumSet保证集合中的元素不重复；EnumMap中的 key 是enum 类型，而 value 则可以是任意类型。
EnumMap
public class Herb {
public enum Type { ANNUAL, PERENNIAL, BIENNIAL }
private final String name;
private final Type type;
Herb(String name, Type type) {
this.name = name;
this.type = type;
}
@Override public String toString() {
return name;
}
}
public static void main(String[] args) {
Herb[] garden = { new Herb("Basil", Type.ANNUAL),
new Herb("Carroway", Type.BIENNIAL),
new Herb("Dill", Type.ANNUAL),
new Herb("Lavendar", Type.PERENNIAL),
new Herb("Parsley", Type.BIENNIAL),
new Herb("Rosemary", Type.PERENNIAL) };
// Using an EnumMap to associate data with an enum - Page 162
Map<Herb.Type, Set<Herb>> herbsByType = new EnumMap<Herb.Type, Set<Herb>>(
Herb.Type.class);
for (Herb.Type t : Herb.Type.values())
herbsByType.put(t, new HashSet<Herb>());
for (Herb h : garden)
herbsByType.get(h.type).add(h);
System.out.println(herbsByType);
}
EnumSet
EnumSet 是枚举类型的高性能 Set 实现，它要求放入它的枚举常量必须属于同一枚举类型。EnumSet 提供了许多工厂方法以便于初始化。
| 方法名称 | 描述 |
|---|---|
| allOf(Class |
创建一个包含指定枚举类型中所有枚举成员的 EnumSet 对象 |
| complementOf(EnumSet |
创建一个与指定 EnumSet 对象 s 相同的枚举类型 EnumSet 对象， 并包含所有 s 中未包含的枚举成员 |
| copyOf(EnumSet |
创建一个与指定 EnumSet 对象 s 相同的枚举类型 EnumSet 对象， 并与 s 包含相同的枚举成员 |
| noneOf(<Class |
创建指定枚举类型的空 EnumSet 对象 |
| of(E first,e...rest) | 创建包含指定枚举成员的 EnumSet 对象 |
| range(E from ,E to) | 创建一个 EnumSet 对象，该对象包含了 from 到 to 之间的所有枚 举成员 |
EnumSet 作为 Set 接口实现，它支持对包含的枚举常量的遍历。
for(Operation op:EnumSet.range(Operation.PLUS,Operation.MULTIPLY)) {
doSomeThing(op);
}