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

最新推荐文章于 2025-07-30 22:21:08 发布
最新推荐文章于 2025-07-30 22:21:08 发布 · 86 阅读 · 0
标签
#java 枚举 #java枚举 #java枚举类型enum用法 #java注解的实现原理 #为什么会有枚举类
本文介绍了Java枚举类型，从JDK1.5开始支持。阐述了枚举类型的定义方式，可像定义类一样定义属性、方法等。还深入分析了其实现原理，通过查看字节码可知，枚举编译后成抽象类，继承自java.lang.Enum，添加了values和valueOf方法，枚举常量用内部类实现，保证了不可变性和单例性。

287d63f842823755a6344e2f1057563c.png

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。

如何定义枚举类型

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

  1. package com.mikan;
  2. /**
  3. * @author Mikan
  4. * @date 2015-08-29 12:06
  5. */
  6. public enum Operator {
  7. ADD,
  8. SUBTRACT,
  9. MULTIPLY,
  10. DIVIDE
  11. }

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

  1. package com.mikan;
  2. /**
  3. * @author Mikan
  4. * @date 2015-08-29 12:06
  5. */
  6. public enum Operator {
  7. ADD {
  8. @Override
  9. public int calculate(int a, int b) {
  10. return a + b;
  11. }
  12. },
  13. SUBTRACT {
  14. @Override
  15. public int calculate(int a, int b) {
  16. return a - b;
  17. }
  18. },
  19. MULTIPLY {
  20. @Override
  21. public int calculate(int a, int b) {
  22. return a * b;
  23. }
  24. },
  25. DIVIDE {
  26. @Override
  27. public int calculate(int a, int b) {
  28. if (b == 0) {
  29. throw new IllegalArgumentException("divisor must not be 0");
  30. }
  31. return a / b;
  32. }
  33. };
  34. public abstract int calculate(int a, int b);
  35. }

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

  1. package com.mikan;
  2. /**
  3. * @author Mikan
  4. * @date 2015-08-29 12:06
  5. */
  6. public enum Operator {
  7. ADD ("+") {
  8. @Override
  9. public int calculate(int a, int b) {
  10. return a + b;
  11. }
  12. },
  13. SUBTRACT ("-") {
  14. @Override
  15. public int calculate(int a, int b) {
  16. return a - b;
  17. }
  18. },
  19. MULTIPLY ("*") {
  20. @Override
  21. public int calculate(int a, int b) {
  22. return a * b;
  23. }
  24. },
  25. DIVIDE ("/") {
  26. @Override
  27. public int calculate(int a, int b) {
  28. if (b == 0) {
  29. throw new IllegalArgumentException("divisor must not be 0");
  30. }
  31. return a / b;
  32. }
  33. };
  34. Operator (String operator) {
  35. this.operator = operator;
  36. }
  37. private String operator;
  38. public abstract int calculate(int a, int b);
  39. public String getOperator() {
  40. return operator;
  41. }
  42. }

实现原理分析

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

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

  1. localhost:mikan mikan$ javap Operator.class
  2. Compiled from "Operator.java"
  3. public abstract class com.mikan.Operator extends java.lang.Enum<com.mikan.Operator> {
  4. public static final com.mikan.Operator ADD;
  5. public static final com.mikan.Operator SUBTRACT;
  6. public static final com.mikan.Operator MULTIPLY;
  7. public static final com.mikan.Operator DIVIDE;
  8. public static com.mikan.Operator[] values();
  9. public static com.mikan.Operator valueOf(java.lang.String);
  10. public abstract int calculate(int, int);
  11. public java.lang.String getOperator();
  12. com.mikan.Operator(java.lang.String, int, java.lang.String, com.mikan.Operator$1);
  13. static {};
  14. }

可以看到，一个枚举在经过编译器编译过后，变成了一个抽象类，它继承了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)；我们定义的构造方法本来只有一个参数，但却变成了三个参数；同时还生成了一个静态代码块。这些具体的内容接下来仔细看看。

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

  1. localhost:mikan mikan$ javap -c -v Operator.class
  2. Classfile /Users/mikan/Documents/workspace/project/algorithm/target/classes/com/mikan/Operator.class
  3. Last modified 2015-8-29; size 1720 bytes
  4. MD5 checksum 478439554cb827fec3c36cf51c8d36da
  5. Compiled from "Operator.java"
  6. public abstract class com.mikan.Operator extends java.lang.Enum<com.mikan.Operator>
  7. Signature: #67 // Ljava/lang/Enum<Lcom/mikan/Operator;>;
  8. SourceFile: "Operator.java"
  9. InnerClasses:
  10. static #24; //class com/mikan/Operator$4
  11. static #19; //class com/mikan/Operator$3
  12. static #14; //class com/mikan/Operator$2
  13. static #9; //class com/mikan/Operator$1
  14. minor version: 0
  15. major version: 51
  16. flags: ACC_PUBLIC, ACC_SUPER, ACC_ABSTRACT, ACC_ENUM
  17. Constant pool:
  18. // 省略常量池信息
  19. {
  20. public static final com.mikan.Operator ADD;
  21. flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
  22. public static final com.mikan.Operator SUBTRACT;
  23. flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
  24. public static final com.mikan.Operator MULTIPLY;
  25. flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
  26. public static final com.mikan.Operator DIVIDE;
  27. flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
  28. public static com.mikan.Operator[] values();
  29. flags: ACC_PUBLIC, ACC_STATIC
  30. Code:
  31. stack=1, locals=0, args_size=0
  32. 0: getstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
  33. 3: invokevirtual #3 // Method "[Lcom/mikan/Operator;".clone:()Ljava/lang/Object;
  34. 6: checkcast #4 // class "[Lcom/mikan/Operator;"
  35. 9: areturn
  36. LineNumberTable:
  37. line 7: 0
  38. public static com.mikan.Operator valueOf(java.lang.String);
  39. flags: ACC_PUBLIC, ACC_STATIC
  40. Code:
  41. stack=2, locals=1, args_size=1
  42. 0: ldc_w #5 // class com/mikan/Operator
  43. 3: aload_0
  44. 4: invokestatic #6 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  45. 7: checkcast #5 // class com/mikan/Operator
  46. 10: areturn
  47. LineNumberTable:
  48. line 7: 0
  49. LocalVariableTable:
  50. Start Length Slot Name Signature
  51. 0 11 0 name Ljava/lang/String;
  52. public abstract int calculate(int, int);
  53. flags: ACC_PUBLIC, ACC_ABSTRACT
  54. public java.lang.String getOperator();
  55. flags: ACC_PUBLIC
  56. Code:
  57. stack=1, locals=1, args_size=1
  58. 0: aload_0
  59. 1: getfield #8 // Field operator:Ljava/lang/String;
  60. 4: areturn
  61. LineNumberTable:
  62. line 46: 0
  63. LocalVariableTable:
  64. Start Length Slot Name Signature
  65. 0 5 0 this Lcom/mikan/Operator;
  66. com.mikan.Operator(java.lang.String, int, java.lang.String, com.mikan.Operator$1);
  67. flags: ACC_SYNTHETIC
  68. Code:
  69. stack=4, locals=5, args_size=5
  70. 0: aload_0
  71. 1: aload_1
  72. 2: iload_2
  73. 3: aload_3
  74. 4: invokespecial #1 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
  75. 7: return
  76. LineNumberTable:
  77. line 7: 0
  78. LocalVariableTable:
  79. Start Length Slot Name Signature
  80. 0 8 0 this Lcom/mikan/Operator;
  81. 0 8 1 x0 Ljava/lang/String;
  82. 0 8 2 x1 I
  83. 0 8 3 x2 Ljava/lang/String;
  84. 0 8 4 x3 Lcom/mikan/Operator$1;
  85. static {};
  86. flags: ACC_STATIC
  87. Code:
  88. stack=5, locals=0, args_size=0
  89. 0: new #9 // class com/mikan/Operator$1
  90. 3: dup
  91. 4: ldc #10 // String ADD
  92. 6: iconst_0
  93. 7: ldc #11 // String +
  94. 9: invokespecial #12 // Method com/mikan/Operator$1."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  95. 12: putstatic #13 // Field ADD:Lcom/mikan/Operator;
  96. 15: new #14 // class com/mikan/Operator$2
  97. 18: dup
  98. 19: ldc #15 // String SUBTRACT
  99. 21: iconst_1
  100. 22: ldc #16 // String -
  101. 24: invokespecial #17 // Method com/mikan/Operator$2."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  102. 27: putstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
  103. 30: new #19 // class com/mikan/Operator$3
  104. 33: dup
  105. 34: ldc #20 // String MULTIPLY
  106. 36: iconst_2
  107. 37: ldc #21 // String *
  108. 39: invokespecial #22 // Method com/mikan/Operator$3."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  109. 42: putstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
  110. 45: new #24 // class com/mikan/Operator$4
  111. 48: dup
  112. 49: ldc #25 // String DIVIDE
  113. 51: iconst_3
  114. 52: ldc #26 // String /
  115. 54: invokespecial #27 // Method com/mikan/Operator$4."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  116. 57: putstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
  117. 60: iconst_4
  118. 61: anewarray #5 // class com/mikan/Operator
  119. 64: dup
  120. 65: iconst_0
  121. 66: getstatic #13 // Field ADD:Lcom/mikan/Operator;
  122. 69: aastore
  123. 70: dup
  124. 71: iconst_1
  125. 72: getstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
  126. 75: aastore
  127. 76: dup
  128. 77: iconst_2
  129. 78: getstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
  130. 81: aastore
  131. 82: dup
  132. 83: iconst_3
  133. 84: getstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
  134. 87: aastore
  135. 88: putstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
  136. 91: return
  137. LineNumberTable:
  138. line 9: 0
  139. line 15: 15
  140. line 21: 30
  141. line 27: 45
  142. line 7: 60
  143. }
  144. localhost:mikan mikan$

下面分析一下字节码中的各部分，其中：

  1. InnerClasses:
  2. static #24; //class com/mikan/Operator$4
  3. static #19; //class com/mikan/Operator$3
  4. static #14; //class com/mikan/Operator$2
  5. static #9; //class com/mikan/Operator$1

从中可以看到它有4个内部类，这四个内部类的详细信息后面会分析。

静态代码块：

  1. static {};
  2. flags: ACC_STATIC
  3. Code:
  4. stack=5, locals=0, args_size=0
  5. // 创建一个Operator$1的内部类对象
  6. 0: new #9 // class com/mikan/Operator$1
  7. 3: dup
  8. // 接下来的三条指令分别是把三个参数推送到栈顶，然后调用Operator$1的编译器生成的<init>方法
  9. 4: ldc #10 // String ADD
  10. 6: iconst_0
  11. 7: ldc #11 // String +
  12. // 调用<init>方法
  13. 9: invokespecial #12 // Method com/mikan/Operator$1."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  14. // 设置ADD属性的值为新创建的对象
  15. 12: putstatic #13 // Field ADD:Lcom/mikan/Operator;
  16. // 接下来是分别初始化另外三个属性SUBTRACT、MULTIPLY、DIVIDE，这里就不再重复
  17. 15: new #14 // class com/mikan/Operator$2
  18. 18: dup
  19. 19: ldc #15 // String SUBTRACT
  20. 21: iconst_1
  21. 22: ldc #16 // String -
  22. 24: invokespecial #17 // Method com/mikan/Operator$2."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  23. 27: putstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
  24. 30: new #19 // class com/mikan/Operator$3
  25. 33: dup
  26. 34: ldc #20 // String MULTIPLY
  27. 36: iconst_2
  28. 37: ldc #21 // String *
  29. 39: invokespecial #22 // Method com/mikan/Operator$3."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  30. 42: putstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
  31. 45: new #24 // class com/mikan/Operator$4
  32. 48: dup
  33. 49: ldc #25 // String DIVIDE
  34. 51: iconst_3
  35. 52: ldc #26 // String /
  36. 54: invokespecial #27 // Method com/mikan/Operator$4."<init>":(Ljava/lang/String;ILjava/lang/String;)V
  37. 57: putstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
  38. // 下面是new了一个长度为4的Operator类型的数组，并分别设置数组中各元素的值为上面的四个属性的值
  39. 60: iconst_4
  40. 61: anewarray #5 // class com/mikan/Operator
  41. 64: dup
  42. 65: iconst_0
  43. 66: getstatic #13 // Field ADD:Lcom/mikan/Operator;
  44. 69: aastore
  45. 70: dup
  46. 71: iconst_1
  47. 72: getstatic #18 // Field SUBTRACT:Lcom/mikan/Operator;
  48. 75: aastore
  49. 76: dup
  50. 77: iconst_2
  51. 78: getstatic #23 // Field MULTIPLY:Lcom/mikan/Operator;
  52. 81: aastore
  53. 82: dup
  54. 83: iconst_3
  55. 84: getstatic #28 // Field DIVIDE:Lcom/mikan/Operator;
  56. 87: aastore
  57. //下面是设置属性$VALUES的值为刚创建的数组
  58. 88: putstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
  59. 91: return

其实编译器生成的这个静态代码块做了如下工作：分别设置生成的四个公共静态常量字段的值，同时编译器还生成了一个静态字段$VALUES，保存的是枚举类型定义的所有枚举常量。相当于下面的代码：

  1. Operator ADD = new Operator1();
  2. Operator SUBTRACT = new Operator1();
  3. Operator MULTIPLY = new Operator1();
  4. Operator DIVIDE = new Operator1();
  5. Operator[] $VALUES = new Operator[4];
  6. $VALUES[0] = ADD;
  7. $VALUES[1] = SUBTRACT;
  8. $VALUES[2] = MULTIPLY;
  9. $VALUES[3] = DIVIDE;

编译器添加的values方法：

  1. public static com.mikan.Operator[] values();
  2. flags: ACC_PUBLIC, ACC_STATIC
  3. Code:
  4. stack=1, locals=0, args_size=0
  5. 0: getstatic #2 // Field $VALUES:[Lcom/mikan/Operator;
  6. 3: invokevirtual #3 // Method "[Lcom/mikan/Operator;".clone:()Ljava/lang/Object;
  7. 6: checkcast #4 // class "[Lcom/mikan/Operator;"
  8. 9: areturn

这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Operator[]类型返回。它相当于下面的代码：

  1. public static com.mikan.Operator[] values() {
  2. return (Operator[])$VALUES.clone();
  3. }

编译器添加的valueOf方法：

  1. public static com.mikan.Operator valueOf(java.lang.String);
  2. flags: ACC_PUBLIC, ACC_STATIC
  3. Code:
  4. stack=2, locals=1, args_size=1
  5. 0: ldc_w #5 // class com/mikan/Operator
  6. 3: aload_0
  7. 4: invokestatic #6 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  8. 7: checkcast #5 // class com/mikan/Operator
  9. 10: areturn

这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.valueOf()）,返回参数字符串表示的枚举常量，另外，这个方法的实现是，调用父类Enum的valueOf方法，并把类型强转成Operator。它相当于如下的代码：

  1. public static com.mikan.Operator valueOf(String name) {
  2. return (Operator)Enum.valueOf(Operator.class, name);
  3. }

生成的内部类

下面看看生成的内部类Operator$1：

  1. localhost:mikan mikan$ javap Operator$1.class
  2. Compiled from "Operator.java"
  3. final class com.mikan.Operator$1 extends com.mikan.Operator {
  4. com.mikan.Operator$1(java.lang.String, int, java.lang.String);
  5. public int calculate(int, int);
  6. }
  7. localhost:mikan mikan$

可以看到，实现内部类是继承自Operator，即

  1. ADD {
  2. @Override
  3. public int calculate(int a, int b) {
  4. return a + b;
  5. }
  6. },

这就是说，我们定义的每个枚举常量，最终都生成了一个像上面这样的内部类。

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

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

从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的，同时实现是抛出相应的异常。这样保证了每个枚举类型及枚举常量都是不可变的。可以利用枚举的这两个特性来实现线程安全的单例。

枚举
Dear_mango的博客
05-24 547
枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。下面先来看看什么是枚举？如何定义枚举？枚举的定义回忆一下下面的程序，这是在没有枚举类型时定义常量常见的方式/** * Created by zejian on 2017/5/7. * Blog...
java枚举类型的实现原理
热门推荐
痴人说梦
08-29 2万+
Java从JDK1.5开始支持枚举，也就是说，Java一开始是不支持枚举的，就像泛型一样，都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫
轻松入门枚举类Enum源码
旅途
06-29 660
一、源码解读 public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { /** * 枚举常量的名称 * 使用toString方法访问此字段。 */ private final String name; ...
JAVA 枚举的基础和原理
sekever的博客
08-10 986
当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。java 为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如ADD、SUBTRACT等，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始，因此该枚举对象可以调用name与ordinal方法。你可以将枚举类当成一个普通的java类，为其添加方法。..
Java枚举的使用和原理深度解析，看这一篇博客就够了
张凯
02-28 1万+
最近在整理Java的知识点，这篇文章讲解枚举的使用和原理，希望可以帮助到大家，也希望能得到大家的支持和关注。本文章原创，转载请说明出处。 文章目录1. 为什么需要枚举2. 枚举类型的特性和使用2.1. 定义枚举2.2. 枚举特性--定义实例变量、实例代码块、实例方法和构造方法2.3. 枚举特性--定义静态变量、静态代码块以及静态方法2.4. 枚举特性--枚举不能继承其他类或枚举，也不可以被继承，但是可以实现接口2.5. 枚举特性--可以用作switch语句2.6. 枚举特性--enum不可以作为数据类型.
Java枚举的实现_java枚举类型的实现原理
weixin_39711348的博客
02-25 207
Java从JDK1.5开始支持枚举，也就是说，Java一开始是不支持枚举的，就像泛型一样，都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫...
java枚举类型原理_java枚举类型的实现原理(转)
weixin_28879085的博客
02-13 276
Java从JDK1.5开始支持枚举，也就是说，Java一开始是不支持枚举的，就像泛型一样，都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫...
java 实现枚举_【Java基础】Java枚举实现原理
weixin_35876682的博客
02-12 267
定义一个事物的所有值的集合。枚举类型的属性因为枚举类型所代表的是一个事物的所有值的集合，所以枚举类型应具有的属性为：枚举类型所具有的值是不可变的。具有所有的值枚举的作用限定值的范围，通常可以用来限制接口的参数的取值范围。枚举的实现原理通过使用反编译命令javap我们可以得出一下结论：编译器将枚举类型编译为final类型的class类。枚举中的每一个枚举值编译为“public static fina...
Java-枚举
qq_54414566的博客
04-24 377
/自定义枚举实现//1：将构造器私有化，防止被new出来//2：去掉set方法，防止该类属性被修改//3：在该类内部创建固定的对象//4：可以加入final关键字//对外暴露对象：public final static//描述//定义四个对象：public static final Season1 SPRING=new Season1("春天","暖");public static final Season1 SUMMER=new Season1("夏天","热");
Java枚举全面详解
最新发布
weixin_39956506的博客
07-30 643
本文全面介绍Java枚举的特性与应用。首先讲解枚举的基础概念、与常量的对比及优势，分析其底层实现原理。随后详细解析枚举核心语法，包括values()/valueOf()等方法，以及在switch语句中的使用。文章深入探讨枚举高级特性，如带属性方法、抽象方法、实现接口等，并介绍EnumSet/EnumMap集合类。此外，还展示枚举在单例、策略等设计模式中的应用，以及序列化、反射等高级主题。最后通过状态机、错误码等实战案例，总结枚举在提升代码可读性、安全性和维护性方面的价值。
java枚举类的作用
InterfaceJ的博客
02-23 9611
java枚举类可以简单地理解为一种特殊的java类,它的主要用途如下:1、作为类型安全的常量。如下,public enum Color { RED, GREEN, BLANK, YELLOW; public static void main(String[] args) { System.out.println(Color.RED);//RED } }之所以打印结果为RED,是因为我们没...
java 枚举使用和原理-用javap分析class
keanu20191101的博客
09-07 666
java 枚举 enum 用javap从class角度看原理 枚举使用
JAVA中枚举类型的作用
小白的成长记
02-17 1844
1.枚举类型，是相当于自己定义的一个数据类型，这个数据类型，一般是自己定义的。  2.作用： 提高程序的安全性。     要让某个类型的变量的取值只能为若干个固定值中的一个，     如果你在引用的过程当中，用到了这几个固定取值中以外的值，编译器就会报错。                                                              
Java枚举详解：从基础到高级应用
xycxycooo的博客
08-11 2562
在Java中，枚举通过enum关键字定义。枚举常量是枚举类型的实例，通常使用大写字母表示。Java枚举是一种强大且灵活的数据类型，通过合理使用枚举，可以提高代码的可读性、安全性和可维护性。本文详细介绍了枚举的概念、定义、使用方法以及高级应用，并通过实际案例展示了枚举的使用场景。希望本文能为读者在Java枚举的学习和应用方面提供有益的参考和启发，帮助读者编写出更清晰、更高效的代码。
Java~枚举的使用
qq_58284486的博客
04-06 5590
目录 枚举的定义 枚举的使用 values()的使用 ordinal()的使用 valueOf()的使用 compareTo()的使用 枚举的优缺点 枚举的定义 枚举是JDK1.5以后引入的。主要用途：将一组常量组织起来，在引入枚举之前表示一组常量通常是使用定义常量的方式： public static final int RED = 1; public static final int GREEN = 2; public static final in...
Java枚举详解
2301_81298401的博客
03-24 3551
如上文所述，枚举可以直接定义方法，就像在任何类中一样。
Java基础 | Java枚举（Enum）详解：从入门到实践
qq_20236937的博客
03-11 7692
Java基础 | Java枚举（Enum）详解：从入门到实践
java 枚举原理
Code-lover's Learning Notes
07-23 1317
我们回忆下所知道的java中的数据类型，java中的数据类型可以分为基本数据类型和引用数据类型。基本数据类型代表的是一种简单的数据结构，比如说我们经常所说的整型，浮点型，字符型，布尔型等。而在java当中有一种特殊的数据类型，我们叫做引用数据类型，而引用数据类型一共有四种，略懂java的人是知道的，这四种分别是类、数组、接口以及今天我要重点讲述的枚举。关于其他三种数据类型有机会我们再在一起讨论。
Java 枚举(enum) 的常见用法和开发规范
dichengyan0013的博客
10-27 3929
JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。 用法一：常量 在JDK1.5 之前，我们定义常量都是： public static final.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 publicenumColor{ RED,GREEN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值