Java | 少年，你真懂枚举吗？

王子周棋洛

已于 2024-05-16 20:52:07 修改

阅读量958

点赞数 31

分类专栏： java base 文章标签： java 枚举 enum 基础

于 2024-05-16 20:50:31 首次发布

本文链接：https://blog.csdn.net/m0_53321320/article/details/138916614

版权

java base 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

✍🏼作者：周棋洛，大三计算机学生。
♉星座：金牛座
🏠主页：我的个人网站
🌐关键：Java 枚举 enum

在这里插入图片描述

引言

最近有读柏拉图的《理想国》，我不禁思考，要做一个看似xx的人，还是要做一个真正xx的人。思考后，我想做一个真正xx的人，虽然可能做不到，但有句话鼓励着我，虽不能至，心向往之。

Java5中添加了enum关键字，今天我们来巩固基础，学习Java枚举的相关知识。

在这里插入图片描述

灵魂发问？

学一个知识，我脑袋中不仅会有好多问号？比如：

什么是枚举？

枚举是一种数据类型，用于表示一组有限且固定的常量集合。枚举类型可以帮助开发人员编写更加清晰、可读性更高的代码，而不需要依赖于魔法数值或者字符串。

什么是java枚举类？

在Java中，枚举通过关键字enum定义，因此Java中的枚举类型也被称为枚举类（Enum class）。枚举类是一种特殊的类，用于表示枚举类型。

枚举类中的每个枚举常量都是类的一个实例，并且这些实例在定义时就被确定了，不能在运行时修改。

枚举类可以有方法，构造函数和字段，因此可以像普通类一样进行操作，但是枚举常量通常是不可变的。

在Java中，枚举类通常用于替代常量集合或者表示状态机等场景，以提高代码的可读性和可维护性。枚举类的使用方式类似于普通类，但其语法更简洁明了，因此很多情况下都是一个不错的选择。

java底层如何处理枚举类？

枚举类在java中被编译为一个普通的类，但是编译器会自动为枚举类添加一些特殊的方法和属性，比如values()方法用于返回枚举常量数组，valueOf()方法用于将字符串转换为对应的枚举常量等。

枚举类为什么不允许new？

在Java中，枚举类型是一种特殊的类，它已经预先定义了一组有限的实例。编译器会自动添加一些特殊的处理，使得枚举常量在类加载时就被创建，并且在整个JVM中只存在一个实例。

枚举常量的创建是在类加载时就完成的，而且在加载枚举类时，编译器会生成相应数量的枚举实例，这些实例是在静态代码块中进行初始化的（我们会在后续的反编译详细研究）。因此，枚举类在加载时就已经创建了所有可能的实例，不需要使用new关键字来实例化。

另外，枚举类通常用于一组有限的常量集合，也就是我们不需要在运行时动态地创建新的实例。因此，禁用new关键字实例化可以确保枚举类型的单例性和稳定性。

在这里插入图片描述

枚举类构造器不允许用public，protected等修饰？

当你给枚举类构造器用public，protected修饰时会提示“此处不允许使用修饰符xxx”，它允许空修饰符或者private修饰符，虽所private修饰符会提示“修饰符 'private' 对于枚举构造函数是冗余的”，但不报错。

为什么private时，提示冗余呢？因为当你定义一个枚举类时，编译器会自动将枚举常量的构造器设为私有的，这是为了防止在类外部创建新的枚举实例。所以，私有构造器可以保证枚举类型的单例性和不变性。

枚举类构造器是私有的，怎么证明？

枚举类的构造器是私有（private）的，怎么证明呢？

枚举类HttpCodeEnum

在枚举类中定义两个构造器。

public enum HttpCodeEnum {
    SUCCESS("成功", 200);

    String msg;
    int code;

    HttpCodeEnum() {
	}

    HttpCodeEnum(String msg, int code) {
        this.msg = msg;
        this.code = code;
    }
}

其实可以通过反射在程序运行时，动态获取构造器的信息，代码如下：

// 获取枚举类的构造方法
Constructor<?>[] declaredConstructors = HttpCodeEnum.class.getDeclaredConstructors();

// 遍历构造方法
for (Constructor<?> constructor : declaredConstructors) {
    // 输出构造方法的修饰符和名称
    System.out.println("Constructor: " + constructor.getModifiers() + " " + constructor.getName());
}

执行上面代码，结果如下：

Constructor: 2 com.zhouql.domain.entity.HttpCodeEnum
Constructor: 2 com.zhouql.domain.entity.HttpCodeEnum

有些小伙伴可能对反射不太了解，没关系看一下getModifiers源码：

/**
 * Returns the Java language modifiers for the executable represented by this object.
 * 返回此对象表示的可执行文件的Java语言修饰符。
 */
@Override
public int getModifiers() {
    return modifiers;
}

该方法的返回值是int，和修饰符的映射如下：
0：可能代表没有任何修饰符修饰。
1：可能代表被 public 修饰符修饰。
2：可能代表被 private 修饰符修饰。
…

这就清楚了，这个类有两个构造器，都是私有（private）的。

反编译，研究透彻

遇事不决，反编译看看，创建一个空的枚举类，如下：

/**
 * Date: 2024/5/15 14:18
 * Author: 王子周棋洛
 * Description: This is a newly created class.
 */

public enum HttpCodeEnum {
	
}

反编译结果如下：

public final class com.zhouql.domain.entity.HttpCodeEnum extends java.lang.Enum<com.zhouql.domain.entity.HttpCodeEnum> {
  public static com.zhouql.domain.entity.HttpCodeEnum[] values();
  public static com.zhouql.domain.entity.HttpCodeEnum valueOf(java.lang.String);
  static {};
}

有点意思了，可以看到枚举类经过编译，其实就是一个Java类啊，只不过它稍微特殊些罢了，我们继续往下看：

final class 关键字，意味着该类不允许被继承。表示枚举类是最终的，不可派生子类。

extends Enum<HttpCodeEnum> 继承自Enum类（java.lang）

看看Enum类的构造器，英语不好，下面是机翻的doc：

独家建造商。程序员无法调用此构造函数。它供编译器在响应枚举类型声明时发出的代码使用。

形参:
name–-此枚举常量的名称，它是用于声明它的标识符。
ordinal–-此列举常量的序号（它在枚举声明中的位置，其中初始常量被分配了一个序号0）。

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

public final int ordinal() {
    return ordinal;
}
public final String name() {
	return name;
}

大概意思是，这是个抽象类，我们无法实例化并手动调用。是提供给编译器在创建枚举类型时用的，形参name就是常量名，ordinal代表常量序号，说明多个常量顺序是有被记录的，有顺序。这也就是为什么我们的enum常量会有ordinal，name这些方法，是不是就合理了。

HttpCodeEnum success = HttpCodeEnum.SUCCESS;
System.out.println(success instanceof Enum);
// true

下面我们给枚举类增加些内容：

public enum HttpCodeEnum {
    SUCCESS("成功", 200);
    String msg;
    int code;
    HttpCodeEnum(String msg, int code) {
        this.msg = msg;
        this.code = code;
    }
}

再次反编译可以得到如下字节码：

public final class com.zhouql.domain.entity.HttpCodeEnum extends java.lang.Enum<com.zhouql.domain.entity.HttpCodeEnum> {
  public static final com.zhouql.domain.entity.HttpCodeEnum SUCCESS;

  java.lang.String msg;

  int code;

  public static com.zhouql.domain.entity.HttpCodeEnum[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[Lcom/zhouql/domain/entity/HttpCodeEnum;
       3: invokevirtual #2                  // Method "[Lcom/zhouql/domain/entity/HttpCodeEnum;".clone:()Ljava/lang/Object;
       6: checkcast     #3                  // class "[Lcom/zhouql/domain/entity/HttpCodeEnum;"
       9: areturn

  public static com.zhouql.domain.entity.HttpCodeEnum valueOf(java.lang.String);
    Code:
       0: ldc           #4                  // class com/zhouql/domain/entity/HttpCodeEnum
       2: aload_0
       3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       6: checkcast     #4                  // class com/zhouql/domain/entity/HttpCodeEnum
       9: areturn

  static {};
    Code:
       0: new           #4                  // class com/zhouql/domain/entity/HttpCodeEnum
       3: dup
       4: ldc           #9                  // String SUCCESS
       6: iconst_0
       7: ldc           #10                 // String 成功
       9: sipush        200
      12: invokespecial #11                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;I)V
      15: putstatic     #12                 // Field SUCCESS:Lcom/zhouql/domain/entity/HttpCodeEnum;
      18: iconst_1
      19: anewarray     #4                  // class com/zhouql/domain/entity/HttpCodeEnum
      22: dup
      23: iconst_0
      24: getstatic     #12                 // Field SUCCESS:Lcom/zhouql/domain/entity/HttpCodeEnum;
      27: aastore
      28: putstatic     #1                  // Field $VALUES:[Lcom/zhouql/domain/entity/HttpCodeEnum;
      31: return
}

有新发现，我们发现这次静态代码块有内容了。

在这里插入图片描述

简单总结，他做了一下工作：

创建了一个 HttpCodeEnum 实例并初始化（SUCCESS）。
将这个实例存储在 HttpCodeEnum 类的静态字段 SUCCESS 中。
创建了一个包含这个 SUCCESS 实例的数组。
将这个数组存储在 HttpCodeEnum 类的静态字段 $VALUES 中。

是不是清晰了，有种恍然大悟的感觉，哈哈。

好了，就到这，不再深究了，下面我们来看看使用篇，怎么用呢？

在这里插入图片描述

使用篇

因为我本人Java代码写的不多，水平比较低。所以我追求想掌握它。

这里参考下Enum的实现类，看看别人都是怎么用枚举类的。

简单枚举

java.nio.file

public enum FileVisitResult {
    CONTINUE,
    TERMINATE,
    SKIP_SUBTREE,
    SKIP_SIBLINGS;
}

用法学习：

定义一个enum关键字声明的枚举类
把需要枚举的常量以大写的形式定义出来
如果只有一个直接分号;结束
如果有多个，用逗号隔开，最后用分号结束
枚举值命名，采用全大写，多个单词用下划线分割

带属性的枚举

HttpCodeEnum

枚举类只是特殊的类，有时候单个枚举常量可能不足以满足我们描述它，因此我们可以提供字段，构造方法，并通过构造方法设置枚举值。

public enum HttpCodeEnum {
    OK(200, "Success"),
    BAD_REQUEST(400, "Bad Request"),
    NOT_FOUND(404, "Not Found");

    private final int code;
    private final String description;

    HttpCodeEnum(int code, String description) {
        this.code = code;
        this.description = description;
    }

    public int getCode() {
        return code;
    }

    public String getDescription() {
        return description;
    }
}

Test

public static void main(String[] args) {
    HttpCodeEnum status = HttpCodeEnum.OK;
    System.out.println("Status code: " + status.getCode() + ", Description: " + status.getDescription());
}

// run
Status code: 200, Description: Success

带有自定义方法的枚举

Operation

通过定义抽象方法，并在枚举常量提供实现。

public enum Operation {
    PLUS {
        public double apply(double x, double y) { return x + y; }
    },
    MINUS {
        public double apply(double x, double y) { return x - y; }
    },
    TIMES {
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE {
        public double apply(double x, double y) { return x / y; }
    };

    public abstract double apply(double x, double y);
}

Test

public static void main(String[] args) {
    double x = 20.0;
    double y = 10.0;
    for (Operation op : Operation.values()) {
        System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
    }
}

// run
20.000000 PLUS 10.000000 = 30.000000
20.000000 MINUS 10.000000 = 10.000000
20.000000 TIMES 10.000000 = 200.000000
20.000000 DIVIDE 10.000000 = 2.000000

带有复杂逻辑的枚举

比如我们用枚举实现交通信号灯控制：

TrafficLight

经过前面的探究，我们知道了每个枚举值都对应枚举类的一个实例，所以可以有构造，方法重写等能力。

看看下面代码是不是就很巧妙。

public enum TrafficLight {
    RED(30) {
        @Override
        public TrafficLight next() {
            return GREEN;
        }
    },
    GREEN(45) {
        @Override
        public TrafficLight next() {
            return YELLOW;
        }
    },
    YELLOW(5) {
        @Override
        public TrafficLight next() {
            return RED;
        }
    };

    private final int duration; // in seconds

    TrafficLight(int duration) {
        this.duration = duration;
    }

    public int getDuration() {
        return duration;
    }

    public abstract TrafficLight next();
}

Test

public static void main(String[] args) {
    TrafficLight currentLight = TrafficLight.RED;

    for (int i = 0; i < 10; i++) {
        System.out.printf("The light is %s for %d seconds.%n", currentLight, currentLight.getDuration());
        currentLight = currentLight.next();
    }
}

// run
The light is RED for 30 seconds.
The light is GREEN for 45 seconds.
The light is YELLOW for 5 seconds.
The light is RED for 30 seconds.
The light is GREEN for 45 seconds.
The light is YELLOW for 5 seconds.
The light is RED for 30 seconds.
The light is GREEN for 45 seconds.
The light is YELLOW for 5 seconds.
The light is RED for 30 seconds.

带有接口的枚举

/**
 * Date: 2024/5/16 19:32
 * Author: 王子周棋洛
 * Description: 定义接口
 */

interface Drawable {
    void draw();
}

/**
 * Date: 2024/5/16 19:32
 * Author: 王子周棋洛
 * Description: 枚举实例实现接口实现draw方法
 */
 
public enum Shape implements Drawable {
    CIRCLE {
        @Override
        public void draw() {
            System.out.println("Drawing a circle");
        }
    },
    SQUARE {
        @Override
        public void draw() {
            System.out.println("Drawing a square");
        }
    }
}

Test

public static void main(String[] args) {
    for (Shape shape : Shape.values()) {
        shape.draw();
    }
}

// run
Drawing a circle
Drawing a square