Java 枚举

1、枚举的作用和好处
JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给开发带来了“大”方便。

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static final.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 

public enum Color {  
 
  RED, GREEN, BLANK, YELLOW  
 
} 
用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。 

enum Signal {  
    GREEN, YELLOW, RED  
}  
 
public class TrafficLight {  
    Signal color = Signal.RED;  
 
    public void change() {  
        switch (color) {  
        case RED:  
            color = Signal.GREEN;  
            break;  
        case YELLOW:  
            color = Signal.RED;  
            break;  
        case GREEN:  
            color = Signal.YELLOW;  
            break;  
        }  
    }  
}  
用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 

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;  
    }  
 
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
 
    // get set 方法  
    public String getName() {  
        return name;  
    }  
 
    public void setName(String name) {  
        this.name = name;  
    }  
 
    public int getIndex() {  
        return index;  
    }  
 
    public void setIndex(int index) {  
        this.index = index;  
    }  
 
}  
用法四：覆盖枚举的方法

下面给出一个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  
    }  
}  
 
/**
* 测试继承接口的枚举的使用
*/
private static void testImplementsInterface() {
for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
System.out.print(dessertEnum + " ");
}
 
System.out.println();
 
for (CoffeeEnum coffee : CoffeeEnum.values()) {
System.out.print(coffee + " ");
}
 
System.out.println();
Food food = Food.DessertEnum.CAKE;
System.out.println(food);
food = CoffeeEnum.BLACK_COFFEE;
System.out.println(food);
 
}
 

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

 

2、枚举的实现原理
总结

枚举本质上是通过普通的类来实现的，只是编译器为我们进行了处理。每个枚举类型都继承自java.lang.Enum，并自动添加了values和valueOf方法。而每个枚举常量是一个静态常量字段，使用内部类实现，该内部类继承了枚举类。所有枚举常量都通过静态代码块来进行初始化，即在类加载期间就初始化。另外通过把clone、readObject、writeObject这三个方法定义为final的，同时实现是抛出相应的异常。这样保证了每个枚举类型及枚举常量都是不可变的。可以利用枚举的这两个特性来实现线程安全的单例。

Java从JDK1.5开始支持枚举，也就是说，Java一开始是不支持枚举的，就像泛型一样，都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫“语法糖”，而编译器的特殊处理叫“解语法糖”。那么像枚举也是在JDK1.5中才引入的，又是怎么实现的呢？

 

Java在1.5中添加了java.lang.Enum抽象类，它是所有枚举类型基类。提供了一些基础属性和基础方法。同时，对把枚举用作Set和Map也提供了支持，即java.util.EnumSet和java.util.EnumMap。

 

如何定义枚举类型

比如表示加减乘除操作，我们可以定义如下枚举：

 
public enum Operator {
ADD,
SUBTRACT,
MULTIPLY,
DIVIDE
}
 
 
public enum Operator {
ADD {
@Override
public int calculate(int a, int b) {
return a + b;
}
},
 
SUBTRACT {
@Override
public int calculate(int a, int b) {
return a - b;
}
 
},
 
MULTIPLY {
@Override
public int calculate(int a, int b) {
return a * b;
}
 
},
 
DIVIDE {
@Override
public int calculate(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("divisor must not be 0");
}
 
return a / b;
 
}
 
};
 
public abstract int calculate(int a, int b);
 
}
 
从上面可以看到，我们基本可以像定义类一样来定义枚举。我们还可以定义属性、构造方法等：
public enum Operator {
ADD ("+") {
@Override
public int calculate(int a, int b) {
return a + b;
}
 
},
 
SUBTRACT ("-") {
@Override
public int calculate(int a, int b) {
return a - b;
}
 
},
 
MULTIPLY ("*") {
@Override
public int calculate(int a, int b) {
return a * b;
}
 
},
 
DIVIDE ("/") {
@Override
public int calculate(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("divisor must not be 0");
}
 
return a / b;
 
}
 
};
 
Operator (String operator) {
this.operator = operator;
}
 
private String operator;
public abstract int calculate(int a, int b);
public String getOperator() {
return operator;
 
}
 
}
实现原理分析

既然可以像使用普通的类一样使用枚举，编译器究竟为我们做了些什么事呢？要想知道这其中的秘密，最有效的途径就是查看生成的字节码。下面就来看看上面定义的枚举生成的字节码是怎么样的。

首先来看看反编译的基本信息：

localhost:mikan mikan$ javap Operator.class
 
Compiled from "Operator.java"
 
public abstract class com.mikan.Operator extends java.lang.Enum<com.mikan.Operator> {
 
public static final com.mikan.Operator ADD;
 
public static final com.mikan.Operator SUBTRACT;
 
public static final com.mikan.Operator MULTIPLY;
 
public static final com.mikan.Operator DIVIDE;
 
public static com.mikan.Operator[] values();
 
public static com.mikan.Operator valueOf(java.lang.String);
 
public abstract int calculate(int, int);
 
public java.lang.String getOperator();
 
com.mikan.Operator(java.lang.String, int, java.lang.String, com.mikan.Operator$1);
 
static {};
 
}
可以看到，一个枚举在经过编译器编译过后，变成了一个抽象类，它继承了java.lang.Enum；而枚举中定义的枚举常量，变成了相应的public static final属性，而且其类型就抽象类的类型，名字就是枚举常量的名字，同时我们可以在Operator.class的相同路径下看到四个内部类的.class文件com/mikan/Operator$1.class、com/mikan/Operator$2.class、com/mikan/Operator$3.class、com/mikan/Operator$4.class，也就是说这四个命名字段分别使用了内部类来实现的；同时添加了两个方法values()和valueOf(String)；我们定义的构造方法本来只有一个参数，但却变成了三个参数；同时还生成了一个静态代码块。这些具体的内容接下来仔细看看。

看下面详细的反编译信息：

localhost:mikan mikan$ javap -c -v Operator.class
Classfile /Users/mikan/Documents/workspace/project/algorithm/target/classes/com/mikan/Operator.class
Last modified 2015-8-29; size 1720 bytes
MD5 checksum 478439554cb827fec3c36cf51c8d36da
Compiled from "Operator.java"
public abstract class com.mikan.Operator extends java.lang.Enum<com.mikan.Operator>
Signature: #67 // Ljava/lang/Enum<Lcom/mikan/Operator;>;
SourceFile: "Operator.java"
InnerClasses:
static #24; //class com/mikan/Operator$4
static #19; //class com/mikan/Operator$3
static #14; //class com/mikan/Operator$2
static #9; //class com/mikan/Operator$1
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER, ACC_ABSTRACT, ACC_ENUM
Constant pool:
// 省略常量池信息
{
public static final com.mikan.Operator ADD;
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
public static final com.mikan.Operator SUBTRACT;
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
public static final com.mikan.Operator MULTIPLY;
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
public static final com.mikan.Operator DIVIDE;
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
public static com.mikan.Operator[] values();
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: getstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
3: invokevirtual #3 // Method "[Lcom/mikan/Operator;".clone:()Ljava/lang/Object;
6: checkcast #4 // class "[Lcom/mikan/Operator;"
9: areturn
LineNumberTable:
line 7: 0
public static com.mikan.Operator valueOf(java.lang.String);
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: ldc_w #5 // class com/mikan/Operator
3: aload_0
4: invokestatic #6 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
7: checkcast #5 // class com/mikan/Operator
10: areturn
LineNumberTable:
line 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 name Ljava/lang/String;
public abstract int calculate(int, int);
flags: ACC_PUBLIC, ACC_ABSTRACT
public java.lang.String getOperator();
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: getfield #8 // Field operator:Ljava/lang/String;
4: areturn
LineNumberTable:
line 46: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/mikan/Operator;
com.mikan.Operator(java.lang.String, int, java.lang.String, com.mikan.Operator$1);
flags: ACC_SYNTHETIC
Code:
stack=4, locals=5, args_size=5
0: aload_0
1: aload_1
2: iload_2
3: aload_3
4: invokespecial #1 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
7: return
LineNumberTable:
line 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 8 0 this Lcom/mikan/Operator;
0 8 1 x0 Ljava/lang/String;
0 8 2 x1 I
0 8 3 x2 Ljava/lang/String;
0 8 4 x3 Lcom/mikan/Operator$1;
static {};
flags: ACC_STATIC
Code:
stack=5, locals=0, args_size=0
0: new #9 // class com/mikan/Operator$1
3: dup
4: ldc #10 // String ADD
6: iconst_0
7: ldc #11 // String +
9: invokespecial #12 // Method com/mikan/Operator$1."<init>":(Ljava/lang/String;ILjava/lang/String;)V
12: putstatic #13 // Field ADD:Lcom/mikan/Operator;
15: new #14 // class com/mikan/Operator$2
18: dup
19: ldc #15 // String SUBTRACT
21: iconst_1
22: ldc #16 // String -
24: invokespecial #17 // Method com/mikan/Operator$2."<init>":(Ljava/lang/String;ILjava/lang/String;)V
27: putstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
30: new #19 // class com/mikan/Operator$3
33: dup
34: ldc #20 // String MULTIPLY
36: iconst_2
37: ldc #21 // String *
39: invokespecial #22 // Method com/mikan/Operator$3."<init>":(Ljava/lang/String;ILjava/lang/String;)V
42: putstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
45: new #24 // class com/mikan/Operator$4
48: dup
49: ldc #25 // String DIVIDE
51: iconst_3
52: ldc #26 // String /
54: invokespecial #27 // Method com/mikan/Operator$4."<init>":(Ljava/lang/String;ILjava/lang/String;)V
57: putstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
60: iconst_4
61: anewarray #5 // class com/mikan/Operator
64: dup
65: iconst_0
66: getstatic #13 // Field ADD:Lcom/mikan/Operator;
69: aastore
70: dup
71: iconst_1
72: getstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
75: aastore
76: dup
77: iconst_2
78: getstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
81: aastore
82: dup
83: iconst_3
84: getstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
87: aastore
88: putstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
91: return
LineNumberTable:
line 9: 0
line 15: 15
line 21: 30
line 27: 45
line 7: 60
}
 
localhost:mikan mikan$
下面分析一下字节码中的各部分，其中：
InnerClasses:
static #24; //class com/mikan/Operator$4
static #19; //class com/mikan/Operator$3
static #14; //class com/mikan/Operator$2
static #9; //class com/mikan/Operator$1
从中可以看到它有4个内部类，这四个内部类的详细信息后面会分析。
静态代码块：
 
 
 
static {};
flags: ACC_STATIC
Code:
stack=5, locals=0, args_size=0
/ 创建一个Operator$1的内部类对象
0: new #9 // class com/mikan/Operator$1
3: dup
// 接下来的三条指令分别是把三个参数推送到栈顶，然后调用Operator$1的编译器生成的<init>方法
4: ldc #10 // String ADD
6: iconst_0
7: ldc #11 // String +
// 调用<init>方法
9: invokespecial #12 // Method com/mikan/Operator$1."<init>":(Ljava/lang/String;ILjava/lang/String;)V
// 设置ADD属性的值为新创建的对象
12: putstatic #13 // Field ADD:Lcom/mikan/Operator;
// 接下来是分别初始化另外三个属性SUBTRACT、MULTIPLY、DIVIDE，这里就不再重复
15: new #14 // class com/mikan/Operator$2
18: dup
19: ldc #15 // String SUBTRACT
21: iconst_1
22: ldc #16 // String -
24: invokespecial #17 // Method com/mikan/Operator$2."<init>":(Ljava/lang/String;ILjava/lang/String;)V
27: putstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
30: new #19 // class com/mikan/Operator$3
33: dup
34: ldc #20 // String MULTIPLY
36: iconst_2
37: ldc #21 // String *
39: invokespecial #22 // Method com/mikan/Operator$3."<init>":(Ljava/lang/String;ILjava/lang/String;)V
42: putstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
45: new #24 // class com/mikan/Operator$4
48: dup
49: ldc #25 // String DIVIDE
51: iconst_3
52: ldc #26 // String /
54: invokespecial #27 // Method com/mikan/Operator$4."<init>":(Ljava/lang/String;ILjava/lang/String;)V
57: putstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
// 下面是new了一个长度为4的Operator类型的数组，并分别设置数组中各元素的值为上面的四个属性的值
60: iconst_4
61: anewarray #5 // class com/mikan/Operator
64: dup
65: iconst_0
66: getstatic #13 // Field ADD:Lcom/mikan/Operator;
69: aastore
70: dup
71: iconst_1
72: getstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
75: aastore
76: dup
77: iconst_2
78: getstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
81: aastore
82: dup
83: iconst_3
84: getstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
87: aastore
//下面是设置属性$VALUES的值为刚创建的数组
88: putstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
91: return
其实编译器生成的这个静态代码块做了如下工作：分别设置生成的四个公共静态常量字段的值，同时编译器还生成了一个静态字段$VALUES，保存的是枚举类型定义的所有枚举常量。相当于下面的代码：
Operator ADD = new Operator1();
Operator SUBTRACT = new Operator1();
Operator MULTIPLY = new Operator1();
Operator DIVIDE = new Operator1();
Operator[] $VALUES = new Operator[4];
$VALUES[0] = ADD;
$VALUES[1] = SUBTRACT;
$VALUES[2] = MULTIPLY;
$VALUES[3] = DIVIDE;
编译器添加的values方法：
public static com.mikan.Operator[] values();
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: getstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
3: invokevirtual #3 // Method "[Lcom/mikan/Operator;".clone:()Ljava/lang/Object;
6: checkcast #4 // class "[Lcom/mikan/Operator;"
9: areturn
这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Operator[]类型返回。它相当于下面的代码：
public static com.mikan.Operator[] values() {
return (Operator[])$VALUES.clone();
}
编译器添加的valueOf方法：
public static com.mikan.Operator valueOf(java.lang.String);
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: ldc_w #5 // class com/mikan/Operator
3: aload_0
4: invokestatic #6 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
7: checkcast #5 // class com/mikan/Operator
10: areturn
 
这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.valueOf()）,返回参数字符串表示的枚举常量，另外，这个方法的实现是，调用父类Enum的valueOf方法，并把类型强转成Operator。它相当于如下的代码：
 
public static com.mikan.Operator valueOf(String name) {
return (Operator)Enum.valueOf(Operator.class, name);
}
 
生成的内部类
 
下面看看生成的内部类Operator$1：
 
 
 
localhost:mikan mikan$ javap Operator\$1.class
 
Compiled from "Operator.java"
 
final class com.mikan.Operator$1 extends com.mikan.Operator {
 
com.mikan.Operator$1(java.lang.String, int, java.lang.String);
 
public int calculate(int, int);
 
}
 
localhost:mikan mikan$
 
可以看到，实现内部类是继承自Operator，即
 
ADD {
 
@Override
 
public int calculate(int a, int b) {
 
return a + b;
 
}
 
},
这就是说，我们定义的每个枚举常量，最终都生成了一个像上面这样的内部类。

构造方法为什么增加了两个参数？

 

 

有一个问题，构造方法我们明明只定义了一个参数，为什么生成的构造方法是三个参数呢？

 

从Enum类中我们可以看到，为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如ADD、SUBTRACT等，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始。在枚举常量初始化时，会自动为初始化这两个字段，设置相应的值，所以才在构造方法中添加了两个参数。即：

 

com.mikan.Operator$1(String name, int ordinal, String operator);

另外三个枚举常量生成的内部类基本上差不多，这里就不重复说明了。

我们可以从Enum类的代码中看到，定义的name和ordinal属性都是final的，而且大部分方法也都是final的，特别是clone、readObject、writeObject这三个方法，这三个方法和枚举通过静态代码块来进行初始化一起，它保证了枚举类型的不可变性，不能通过克隆，不能通过序列化和反序列化来复制枚举，这能保证一个枚举常量只是一个实例，即是单例的，所以在effective java中推荐使用枚举来实现单例。
2229

来源：https://blog.csdn.net/weixin_41577923/article/details/102778388