目录
枚举是什么
枚举（enum）： 是一种特殊的类，用于定义一组常量，将其组织起来。枚举使得代码更具有可读性和可维护性，特别是在处理固定集合的值时，如：星期、月份、状态码等
在 Java 中，使用关键字enum来定义枚举类：
java
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}其中，定义的枚举项就是该类的实例，且必须在第一行，最后一个枚举项后的分号**;**可以省略，但是若枚举类有其他内容，则分号不能省略（最好不要省略）
当类初始化时，这些枚举项就会被实例化
枚举类使用 enum 定义后，默认继承 java.lang.Enum 类，也就是说，我们自己写的枚举类，就算没有显示的继承 Enum，但是其默认继承了这个类
此外，枚举在 Java 中**不能被继承，自定义的枚举类隐式继承自 java.lang.Enum 类，且不能再继承其他类，**这样的设计确保了枚举类的简单性和一致性。如果枚举可以继承其他类，将会导致复杂的继承关系，并且影响Java的类型系统
常用方法
| 方法 | 描述 |
|---|---|
| values() | 以数组的形式返回枚举类型的所有成员 |
| ordinal() | 获取枚举成员的索引位置 |
| valueOf() | 将普通字符串转换为枚举实例 |
| compareTo(E o) | 比较两个枚举成员在定义时的顺序 |
我们通过一个示例，来学习和使用这些方法：
java
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
public static void main(String[] args) {
// 获取所有枚举成员
Day[] days = Day.values();
// 遍历
for (int i = 0; i < days.length; i++) {
// 获取枚举成员以及索引位置
System.out.println(days[i] + " " + days[i].ordinal());
}
// 将普通字符串转换为枚举实例
System.out.println(Day.valueOf("THURSDAY"));
// 获取枚举实例 SUNDAY 和 SATURDAY
Day sunday = Day.SUNDAY;
Day saturday = Day.SATURDAY;
// 比较定义时的顺序
System.out.println(sunday.compareTo(saturday));
}
}运行结果：
在使用valueOf() 方法进行转换时，传递的名称必须与枚举常量的名字完全匹配（包括大小写） ，若不匹配，就会抛出 IllegalArgumentException异常：
当我们查看 java.lang.Enum 时：
可以看到，valueOf() 方法包含了两个类型的参数：Class<T> enumClass 和 String name
其中
Class<T> enumType 是一个Class 对象，表示要查找的枚举类型
String name: 是一个字符串，表示要查找的枚举常量的名称。名称必须与枚举常量的名字完全匹配（包括大小写）
但是在使用时，我们只传递了一个参数 name，也能够进行转换，这是为什么呢？
这是因为，在 Java 中，valueOf 方法实际上是自动生成的 ，属于每个枚举类型的特性 。虽然它的原始定义需要两个参数（类类型和名称），但是每个枚举类型都会自动提供一个与自身类型相关联的 valueOf 方法，只需传递一个字符串参数
因此，当我们调用 Day.valueOf("THURSDAY") 时，Java会自动处理这个调用，实际调用的是包含类名的 valueOf 方法，而不是原始的静态方法定义
再观察 java.lang.Enum：
我们会发现，其中**并不存在 values()**这个方法，而当我们点击 values() 方法时，则会跳转到本类上
那么，values() 方法是从哪来的呢？
values() 方法是枚举类自动提供的一个静态方法 ，允许我们获取一个包含所有枚举常量的数组，这个方法是由Java编译器自动生成的，在编译时每个枚举类型都会自动生成一个 values() 方法，因此不需要我们显式定义它
我们将枚举类进行反编译：
（1）打开 cmd，切换到 Day.java 文件所在目录
（2）编译 .java 文件（javac Day.java）
（3）将 .class 文件进行反编译（javap -c Day.class > day.txt）
打开 day.txt，可以看到：
编译器自动为我们生成了 values 和 valueOf 方法
构造方法
当我们创建构造方法时：
不能使用 public 来修饰构造方法，为什么呢？
这是因为，在 Java 中，**枚举类的构造方法都是私有的（不加任何修饰符时，默认是 private），无法在枚举类外部调用，**这也就防止了在枚举类外部创建新的枚举常量
在定义枚举常量时，构造方法会被隐式调用：
java
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
Day() {
System.out.println("构造方法");
}
public static void main(String[] args) {
System.out.println("------------------");
}
}运行结果：
当我们定义带有参数的构造方法时，在创建枚举项时，也要为其提供对应参数：
java
public enum Day {
SUNDAY("周天", 7),
MONDAY("周一", 1),
TUESDAY("周二", 2),
WEDNESDAY("周三", 3),
THURSDAY("周四", 4),
FRIDAY("周五", 5),
SATURDAY("周六", 6);
private String name;
private int key;
Day(String name, int key) {
this.name = name;
this.key = key;
}
}枚举的优缺点
优点：
（1）枚举常量确保了只能使用定义的常量，避免了使用整型常量时可能带来的错误
（2）使用枚举可以使代码更易读，表达清晰
（3）枚举定义了一组固定的常量，适合表示有限的状态或选项，便于管理和维护
（4）枚举可以拥有字段、方法和构造方法，能够封装与常量相关的行为和属性
（5）Java的枚举类自带一些方法，如 values()、valueOf() 等
（6）可以用于 switch 语句
缺点：
（1）枚举的集合是固定的，无法在运行时添加或删除常量。如果需要动态的集合，枚举可能不适用
（2）枚举不能继承，无法扩展
（3）每个枚举常量都是一个对象，可能会增加内存使用，特别是当枚举常量数量较多时
枚举和反射
在 Java 反射-CSDN博客 中，我们学习了反射，通过反射，我们可以拿到类的私有构造方法，从而创建实例对象
那么，枚举是否可以通过反射，拿到实例对象呢？
java
public enum Day {
SUNDAY("周天", 7),
MONDAY("周一", 1),
TUESDAY("周二", 2),
WEDNESDAY("周三", 3),
THURSDAY("周四", 4),
FRIDAY("周五", 5),
SATURDAY("周六", 6);
private String name;
private int key;
Day(String name, int key) {
this.name = name;
this.key = key;
}
}
java
public class Test {
public static void main(String[] args) {
Class<?> classDay = null;
try {
classDay = Class.forName("Day");
Constructor<?> constructor = classDay.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);
Day day = (Day) constructor.newInstance("sunday", 0);
System.out.println(day.ordinal());
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}运行结果：
此时程序抛出了 NoSuchMethodException异常，也就是没有对应的构造方法
但是提供的枚举的构造方法就是带有两个参数，分别为 String 和 int：
那么，问题出在哪里呢？
自定义的枚举类默认继承自java.lang.Enum
因此，自定义的枚举类继承了父类除构造方法外的所有东西，且子类需要帮助父类进行构造，
但我们实现的类中，并没有帮助父类进行构造
因此，我们需要在枚举类中帮助父类进行构造，而父类中的构造方法为：
那么，如何实现呢？通过 super 方法吗？
但是，当我们在构造方法中调用 super 时：
枚举构造方法中不能使用 super
由于枚举比较特殊，在构造方法中，除了我们自定义了两个参数，它还默认添加了父类的两个参数
也就是说，构造函数中一共有四个参数：String int String int
其中，前两个参数是父类参数，后两个参数是子类参数
java
public class Test {
public static void main(String[] args) {
Class<?> classDay = null;
try {
classDay = Class.forName("enumDemo.Day");
Constructor<?> constructor = classDay.getDeclaredConstructor(String.class, int.class, String.class, int.class);
constructor.setAccessible(true);
Day day = (Day) constructor.newInstance("父类参数", 0, "子类参数", 0);
System.out.println(day.ordinal());
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}再次运行：
此时抛出了 IllegalArgumentException 异常，不能通过反射创建枚举对象
枚举保证了每个枚举常量只有一个实例，这种唯一性在枚举类型被定义时就已经确定，不允许外部创建新的实例，枚举类型的设计使得它们的实例在类加载时被唯一地定义，从而避免了通过反射创建新的枚举实例的可能性，确保了枚举的强类型安全性和唯一性
实现单例模式
在 单例模式：饿汉模式、懒汉模式_单例模式懒汉和饿汉-CSDN博客 中我们实现了单例模式 ，单例模式能够确保一个类只有一个实例
但普通类可以通过反射机制打破，因此，我们可以使用枚举来实现单例模式
java
public enum Singleton {
INSTANCE;
public Singleton getInstance() {
return INSTANCE;
}
}