java枚举类型的实现原理

最新推荐文章于 2024-05-14 19:01:55 发布
最新推荐文章于 2024-05-14 19:01:55 发布
阅读量2.4w 收藏 82
点赞数 37
分类专栏： java 文章标签： java枚举实现 枚举原理分析 Enum
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mhmyqn/article/details/48087247
版权

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<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中推荐使用枚举来实现单例。

总结

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

MikanMu
关注
  • 37
    点赞
  • 踩
  • 82
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
【搞定Java基础】第14篇：Java 枚举类型（Enum）
Java学习
01-20 727
本文转发自：https://blog.csdn.net/javazejian/article/details/71333103 本文目录： 1、理解枚举类型 1.1、枚举的定义 1.2、枚举实现原理 1.3、枚举的常见方法 2、枚举与 Class 对象 3、枚举的进阶用法 3.1、向enum类添加方法与自定义构造函数 3.2、关于覆盖 enum 类方法 3.3、enum 类中定...
Java 枚举实现原理
勿忘初心
02-23 6059
枚举 反编译 示意枚举类如下： package com.jiankunking.test; public enum ApplicationInterfaceTypeEnum { dubbo("dubbo", 1), webapp("webapp", 2), custom("custom", 3); private String name; private int...
【Java基础】枚举类的方法及应用
最新发布
qq_43714449的博客
05-14 1327
enum中构造方法默认被private修饰SPRING("春季"),SUMMER("夏季"),AUTUMN("秋季"),WINTER("冬季");Season(){} //默认就是privateSeason(String desc){//默认就是private……………………
深入Java 1.5枚举类型的内部
幽客独往
12-19 4483
    Java是一种面向对象的高级编程语言。它的出众之处就在于它的简洁。一个程序员所要做的就是创建类（Create Class）以及定义接口（Define Interface），如此而已。当然，这种简洁和优美是有代价的，比如失去了Enum这种广泛使用的数据类型就是一个不小的损失。在Java 1.5以前，程序员们不得不通过一些变通的方法来间接的解决这一问题。比如说，被普遍使用的整数枚举替代法和类型
java 枚举的实现原理
BlueKitty的博客
12-18 441
在java中 , 枚举实际上是一个特殊的类 public enum TestEnum { VAL1, VAL2; public static void main(String[] args) { System.out.println(TestEnum.VAL1); } } 编译后内部实现的方式 //继承java.lang.Enum并声明为...
Java枚举实现原理
johnjoe's blog
03-29 204
编译枚举EnumImplMechanism.java，通过jad反编译获得EnumImplMechanism.jad文件 D:\>javac EnumImplMechanism.java D:\>jad EnumImplMechanism.class Parsing EnumImplMechanism.class... Generating EnumImplMechanism.jad ...
Java学习整理系列之Java枚举类型的原理
Sup_Heaven的专栏
06-28 9132
本以为RED只是一个Light类的一个static final的实例而已。但后然发现不是这样的 ，
Java Switch对各类型支持实现原理
08-19
在Java编程语言中，`switch`语句是一种条件控制结构，它允许根据不同的情况执行不同的代码块。早期的Java版本中，`switch`语句只支持基本数据...在编写代码时，理解这些实现原理可以帮助我们更好地理解和优化程序性能。
java 枚举(enum) 详解（学习资料）
06-17
可以通过 `values()` 方法获取枚举类型的全部枚举常量，返回一个枚举类型的数组。 总结来说，Java 枚举提供了一种强类型、安全且易于使用的机制，用于表示一组固定数量的值。它简化了代码，提高了程序的可读性和可...
JAVA 枚举单例模式及源码分析的实例详解
08-29
JAVA 枚举单例模式详解 JAVA 枚举单例模式是一种特殊的单例模式实现方式，它使用枚举类型来保证线程安全、防止序列化问题和反射攻击。下面我们将详细解释这个模式的...它的实现原理是基于类加载机制和枚举类型的特性。
java实现词法分析器——编译原理实验
04-13
4. **处理词法单元**：一旦识别出一个词法单元，就需要将其记录下来，可以使用枚举类型表示不同的词法单元类型，并创建一个枚举实例来存储相关的信息，如关键字的名称、常数的值等。 5. **错误处理**：遇到无效的...
JAVA字符串类型switch的底层原理详析
08-25
但是，后来的JDK版本中，switch语句可以处理字符串类型和枚举类型。这是因为，JVM在处理字符串类型时，会将其转换为hashCode，然后使用hashCode进行比较。 在JVM中，switch语句的处理可以分为两步：首先，JVM会将...
java实现Z字形扫描程序
08-26
在程序中，我们使用了枚举类型Direction来表示扫描的方向，包括DOWN、RIGHT_UP、RIGHT和LEFT_DOWN四种方向。然后，我们使用switch语句来控制扫描的方向，根据当前的方向和位置来判断下一步的扫描方向。 在扫描的...
记分牌算法 组成原理实验 java实现
03-29
可以使用布尔变量或枚举类型来表示运算单元的状态。 3. **依赖分析**：在执行指令前，需要检查其依赖的运算结果是否已经准备好。这可以通过遍历记分牌并检查相关运算单元的状态来实现。 4. **指令调度**：一旦所有...
JAVA实现超级玛丽.zip
05-16
开发者会用一个枚举类型来表示这些状态，并根据状态改变调整游戏行为。 9. **音频播放**：为了增强游戏体验，开发者可能会使用Java的Sound API来播放背景音乐和音效。 10. **资源管理**：图像、音频和其他游戏资源...
Java switch关键字原理及用法详解
08-25
* 实现枚举类型的switch * 实现String类型的switch switch关键字是Java编程语言中的一个重要结构，它提供了一种灵活的方式来根据不同的条件执行不同的代码块。同时，switch关键字也存在一些限制和注意事项，例如...
java 实现枚举_java枚举的实现原理
weixin_40000702的博客
02-12 178
基本使用首先，所有枚举类型都有一个基类：java.lang.Enum抽象类，里面提供了一些基础属性和基础方法。枚举类型不仅可以定义枚举常量，还可以定义属性、构造方法、普通方法、抽象方法等，比如，我们定义了一个包含成员变量，构造方法以及抽象方法的四则运算操作符枚举类型：public enum Operator {ADD("+") {@Overridepublic int calculate(int ...
Java枚举以及实现原理
我叫王哈哈
05-01 941
枚举
Java枚举类型详解(原理+用法)
路漫漫 始于足下
03-02 1279
可以这么说，Java的枚举类型本来是不存在的，但Java发了个"语法糖"，就有了枚举类型。Java从JDK1.5开始支持枚举，通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这个术语
java枚举类型enum用法_java枚举类型enum用法和原理介绍【传智播客】
05-25
Java的枚举类型（enum）是一种特殊的数据类型，它允许我们定义一个有限个数的常量集合。枚举常量可以作为变量使用，但是只能是预定义的常量值之一，不能改变枚举常量的值。 下面是Java中枚举类型的基本语法： ``` enum 枚举类型名称 { 枚举常量1, 枚举常量2, ... } ``` 其中，枚举类型名称是我们自己定义的枚举类型名称，枚举常量是预定义的常量值。 例如： ``` enum Weekday { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } ``` 上面的代码定义了一个名为Weekday的枚举类型，包含了一周的七天。 枚举类型的原理是在编译时将枚举类型转换为一个类。枚举类型中的每个枚举常量都是该类的一个实例。枚举类型还可以定义构造函数、方法和实现接口等。 枚举类型的优点是可以提高代码的可读性和可维护性。使用枚举类型可以避免使用魔法数字，例如使用Weekday.MONDAY代替数字1，这样可以使代码更加清晰易懂。此外，如果需要添加新的枚举常量，只需要在枚举类型中添加一个常量即可，不需要修改其他代码。 枚举类型的缺点是相对于常量集合而言，它的性能可能会稍微差一些。此外，枚举类型也不能完全替代常量集合，例如在需要动态生成常量值的情况下，就需要使用常量集合。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值