java 枚举整形_java枚举类型的实现原理

布满荆棘的人生 2022-11-05 04:28 277阅读 0赞

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。

如何定义枚举类型

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

package com.mikan;

/\*\*

\* @author Mikan

\* @date 2015-08-29 12:06

\*/

public enum Operator \{

ADD,

SUBTRACT,

MULTIPLY,

DIVIDE

上面的枚举定义了四个枚举常量，同时，在枚举中还可以定义普通方法、抽象方法，如下所示：

package com.mikan;

/\*\*

\* @author Mikan

\* @date 2015-08-29 12:06

\*/

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);

从上面可以看到，我们基本可以像定义类一样来定义枚举。我们还可以定义属性、构造方法等：

package com.mikan;

/\*\*

\* @author Mikan

\* @date 2015-08-29 12:06

\*/

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 \{

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

Signature: \#67 // Ljava/lang/Enum;

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 "":(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."":(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."":(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."":(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."":(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的编译器生成的方法

4: ldc \#10 // String ADD

6: iconst\_0

7: ldc \#11 // String +

// 调用方法

9: invokespecial \#12 // Method com/mikan/Operator$1."":(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."":(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."":(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."":(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中推荐使用枚举来实现单例。

总结

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