目录
枚举是什么
常用方法
构造方法
枚举的优缺点
枚举和反射
实现单例模式
枚举是什么
枚举（enum）：是一种特殊的类，用于定义一组常量，将其组织起来。枚举使得代码更具有可读性和可维护性，特别是在处理固定集合的值时，如：星期、月份、状态码等
在 Java 中，使用关键字 enum 来定义枚举类：
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) | 比较两个枚举成员在定义时的顺序 |
我们通过一个示例，来学习和使用这些方法：
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），无法在枚举类外部调用，这也就防止了在枚举类外部创建新的枚举常量
在定义枚举常量时，构造方法会被隐式调用：
public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY; Day() { System.out.println("构造方法"); } public static void main(String[] args) { System.out.println("------------------"); }}运行结果：
当我们定义带有参数的构造方法时，在创建枚举项时，也要为其提供对应参数：
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博客 中，我们学习了反射，通过反射，我们可以拿到类的私有构造方法，从而创建实例对象
那么，枚举是否可以通过反射，拿到实例对象呢？
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; }}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
其中，前两个参数是父类参数，后两个参数是子类参数
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博客 中我们实现了单例模式，单例模式能够确保一个类只有一个实例
但普通类可以通过反射机制打破，因此，我们可以使用枚举来实现单例模式
public enum Singleton { INSTANCE; public Singleton getInstance() { return INSTANCE; }}