Java 基础学习四：Enum 枚举类
Java 基础学习四：枚举类
参考
IBM DeveloperWorks 学习
java enum(枚举)使用详解 + 总结
Java Design Demo–枚举类型–避免嵌套过多 – 思维转变，建议参考
Java枚举中嵌套枚举用例
背景
枚举出现前的状况
在 java 语言中还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组常量（通常利用 public final static 方法定义）。
public 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; // 冬天
} 这种方法称作 int枚举模式。
可这种模式有什么问题呢，我们都用了那么久了，应该没问题的。通常我们写出来的代码都会考虑它的安全性、易用性和可读性。
1、首先我们来考虑一下它的类型安全性（当然这种模式不是类型安全的）
比如说我们设计一个函数，要求传入春夏秋冬的某个值。但是使用 int类型，我们无法保证传入的值为合法。
private String getChineseSeason(int season){
StringBuffer result = new StringBuffer();
switch(season){
case Season.SPRING :
result.append("春天");
break;
case Season.SUMMER :
result.append("夏天");
break;
case Season.AUTUMN :
result.append("秋天");
break;
case Season.WINTER :
result.append("冬天");
break;
default :
result.append("地球没有的季节");
break;
}
return result.toString();
}
public void doSomething(){
// 正常使用场景
System.out.println(this.getChineseSeason(Season.SPRING));
// 不正常使用场景：这不是我们需要的场景，但编译的确能通过，导致类型不安全问题
System.out.println(this.getChineseSeason(5));
}程序 getChineseSeason(Season.SPRING) 是我们预期的使用方法。可 getChineseSeason(5) 显然就不是了，而且编译能通过。这显然就不符合Java程序的类型安全。
2、接下来我们来考虑一下这种模式的可读性
使用枚举的大多数场合，我们都需要方便得到枚举类型的字符串表达式。如果将int枚举常量打印出来，我们所见到的就是一组魔鬼数字（特别是读日志时），看到 1 很难联想到代表春天。
我们可能会想到使用String常量代替 int常量。虽然它为这些常量提供了可打印的字符串，但是它会导致性能问题，因为它依赖于字符串的比较操作，所以这种模式也是我们不期望的。
从类型安全性和程序可读性两方面考虑，int和String枚举模式的缺点就显露出来了。
Java 1.5 引入枚举
Java 1.5 引入的枚举，很好地避免掉了 int和String枚举模式的缺点，同时还有一些额外的好处。
枚举类型（Enumerated Type）是将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围。
1、增加了 命名空间
不用枚举时，季节只是类的属性，引用的时候不得不通过类来访问。但如果常量类里引入多组常量时就有可能造成混淆，当然也可以加一个“SEASON_”前缀，但要加7个前缀，读和写也相应的增加了麻烦。
2、增强了 一致性
int枚举属于编译期常量，编译后，所有客户端和服务器端引用的地方，会直接将整数值写入。这样，当你修改旧的枚举整数值后或者增加新的枚举值后，所有引用地方代码都需要重新编译，否则运行时刻就会出现错误。
3、扩大了 switch 语句使用范围。 5.0 之前，Java 中 switch 的值只能够是简单类型，比如 int、byte、short、char, 有了枚举类型之后，就可以使用对象了。
用枚举重写上面代码：
public class UseSeason {
/**
* 将英文的季节转换成中文季节
* @param season
* @return
*/
public String getChineseSeason(Season season){
StringBuffer result = new StringBuffer();
switch(season){
case SPRING :
result.append("[中文：春天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case AUTUMN :
result.append("[中文：秋天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case SUMMER :
result.append("[中文：夏天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case WINTER :
result.append("[中文：冬天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
default :
result.append("地球没有的季节 " + season.name());
break;
}
return result.toString();
}
public void doSomething(){
for(Season s : Season.values()){
System.out.println(getChineseSeason(s));//这是正常的场景
}
//此处已经是编译不通过了，这就保证了类型安全
//System.out.println(getChineseSeason(5));
}
public static void main(String[] arg){
UseSeason useSeason = new UseSeason();
useSeason.doSomething();
}
}枚举类型源码分析
package java.lang;
import java.io.Serializable;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
/**
* 枚举类型符合通用模式 Class Enum>，而 E 表示枚举类型的名称。
* 枚举类继承的是 Enum 类（非 Object）
*/
public abstract class Enum<E extends Enum<E>>
implements Comparable, Serializable {
/**
* 枚举常量的名称（在枚举声明中对其进行声明）
*/
private final String name;
/**
* 返回枚举常量的名称，用toString()方法获得常量名而不是访问该变量
*/
public final String name() {
return name;
}
/**
* 枚举常量的位置（下标，从0开始）
* 为复杂的基于枚举的数据结构设计。像：{@link java.util.EnumSet}、{@link java.util.EnumMap}.
*/
private final int ordinal;
/**
* 返回枚举常量的位置
*/
public final int ordinal() {
return ordinal;
}
/**
* 枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。
*/
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
/**
* 返回枚举常量的名称，它包含在声明中
*/
public String toString() {
return name;
}
public final boolean equals(Object other) {
return this==other;
}
public final int hashCode() {
return super.hashCode();
}
protected final Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
/**
* 比较此枚举与指定对象的顺序
*/
public final int compareTo(E o) {
Enum other = (Enum)o;
Enum self = this;
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.ordinal;
}
/**
* 返回与此枚举常量的枚举类型相对应的 Class 对象
*/
@SuppressWarnings("unchecked")
public final Class getDeclaringClass() {
Class clazz = getClass();
Class zuper = clazz.getSuperclass();
return (zuper == Enum.class) ? (Class)clazz : (Class)zuper;
}
/**
* 返回带指定名称的指定枚举类型的枚举常量
*/
public static extends Enum> T valueOf(Class enumType,
String name) {
T result = enumType.enumConstantDirectory().get(name);
if (result != null)
return result;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException(
"No enum constant " + enumType.getCanonicalName() + "." + name);
}
/**
* 枚举类不该有finalize()方法
*/
protected final void finalize() { }
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
throw new InvalidObjectException("can't deserialize enum");
}
private void readObjectNoData() throws ObjectStreamException {
throw new InvalidObjectException("can't deserialize enum");
}
} 定义 Enum 类
简单定义：enum + 枚举类名称 + { 枚举值1, 枚举值2 … 枚举值n }
enum SeasonType { SPRING, SUMMER, AUTUMN, WINTER }
// 这段代码实际上调用了 4 次 Enum(String name, int ordinal)：
new Enum("SPRING", 0);
new Enum("SUMMER", 1);
new Enum("AUTUMN", 2);
new Enum("WINTER", 3); 定义形式看似简单，但它不仅是简单地将整形数值转换成对象，而是将枚举类型定义转变成一个完整功能的类定义。
枚举类是一个特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以定义自己的构造器。但枚举类与普通类还是有区别的：
- 创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（即枚举类默认继承 java.lang.Enum 类，而非 Object 类），因此枚举类不能显示 extends 其他父类；但枚举类仍可以 implements 一个或多个接口（Interface）；
- Java 为 Enum 类型提供了高质量的实现，比如默认实现 Comparable 和 Serializable 接口，让开发者一般情况下不用关心这些细节；
- 枚举可以单独定义在一个文件中，也可以嵌在其它Java类中；
- 使用 enum 定义、非抽象的枚举类默认会使用 final 修饰，因此枚举类不能派生子类；
- 枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。枚举值之间用英文逗号
","隔开，枚举值结束后用英文分号";"结束（如果枚举类没有属性及方法时，可以不带结束符）；系统自动给每个实例添加 public static final 修饰，无须显式添加； - 枚举类中的枚举值可以没有参数，也可以有多个参数；
- 枚举类的构造器只能使用 private 修饰符（如果不写，默认 private 修饰符）；
- 可以定义新的属性（默认 private 修饰）；
- 可以定义新的方法；
实战
枚举在各个语言当中都有着广泛的应用，通常用来表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量。
参数
无参
public enum SeasonType {
SPRING, SUMMER, AUTUMN, WINTER
}应用
// 根据实际情况选择下面的用法即可
SeasonType springType = SeasonType.SPRING; // 输出 SPRING
String springString = SeasonType.SPRING.toString(); // 输出 SPRING一参
public enum SeasonType {
// 通过构造函数传递参数并创建实例
SPRING("spring"), SUMMER("summer"), AUTUMN("autumn"), WINTER("winter");
// 定义实例对应的参数
private String msg;
// 必写：通过此构造器给枚举值创建实例
SeasonType(String msg) {
this.msg = msg;
}
// 通过此方法可以获取到对应实例的参数值
public String getMsg() {
return msg;
}
}应用
// 当我们为某个实例类赋值的时候可使用如下方式
String msg = SeasonType.SPRING.getMsg(); // 输出 spring两参
public enum Season {
// 通过构造函数传递参数并创建实例
SPRING(1, "spring"), SUMMER(2, "summer"), AUTUMN(3, "autumn"), WINTER(4, "winter");
// 定义实例对应的参数
private int key;
private String msg;
// 必写：通过此构造器给枚举值创建实例
Season(int key, String msg) {
this.key = key;
this.msg = msg;
}
// 通过此方法可以获取到对应实例的 key 值
public Integer getKey() {
return key;
}
// 通过此方法可以获取到对应实例的 msg 值
public String getMsg() {
return msg;
}
// 很多情况，我们可能从前端拿到的值是枚举类的 key ，然后就可以通过以下静态方法获取到对应枚举值
public static String getValueByKey(int key) {
for (Season season : Season.values()) {
if (season.getKey() == key) {
return season.getValue();
}
}
throw new IllegalArgumentException("No element matches " + key);
}
}应用
// 输出 key 为 1 的枚举值实例
Season season = Season.valueofKey(1);
// 输出 SPRING 实例对应的 key
Integer key = Season.SPRING.getKey();
// 输出 SPRING 实例对应的 msg
String msg = Season.SPRING.getMsg();读取：遍历或switch
switch 语句也能用 enum，可读性更强。
enum Signal {
RED, GREEN, YELLOW
}
public class TrafficLight {
public static void main(String[] args) {
// 遍历
for (Signal s : Signal.values()) {
System.out.println(s.toString()); // 依次输出三行值：RED, GREEN, YELLOW
}
System.out.println("----------------我是分隔线------------------");
// Switch
Signal color = Signal.RED;
switch (color) {
case RED:
System.out.println("红灯停");// 输出
break;
case GREEN:
System.out.println("绿灯行");
break;
case YELLOW:
System.out.println("黄灯亮了等一等");
break;
}
System.out.println("getDeclaringClass(): " + color.getDeclaringClass().getName());// getDeclaringClass(): com.wsh.test.Signal
System.out.println("name(): " + color.name());// name(): RED
System.out.println("toString(): " + color.toString());// toString(): RED
System.out.println("ordinal(): " + color.ordinal());// ordinal(): 0
}
}覆盖枚举的方法
下面给出一个toString()方法覆盖的例子。
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;
}
}实现接口
所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。但可以实现任意接口。
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour{
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 getInfo() {
return this.name;
}
//接口方法
@Override
public void print() {
System.out.println(this.index+":"+this.name);
}
}使用接口组织枚举
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。