本小节我们将一起学习 Java 枚举类，将涉及到什么是枚举类、为什么需要枚举类，如何自定义枚举类以及如何使用枚举类，Enum 类的常用方法等内容。理解为什么需要枚举类以及学会自定义枚举类是本小节学习的重点。

1. 什么是枚举类

在数学和计算机科学中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的技术。

枚举是一个被命名的整型常数的集合。枚举在生活中非常常见，列举如下：

  • 表示星期几：SUNDAY、MONDAY、TUESTDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举；
  • 性别：MALE（男）、FEMALE（女）也是一个枚举；
  • 订单的状态：PAIDED（已付款）、UNPAIDED（未付款）、FINISHED（已完成），CANCELED（已取消）。

知道了什么是枚举，我们就很容易理解什么是枚举类了，简单来说，枚举类就是一个可以表示枚举的类，当一个类的对象只有有限个、确定个的时候，我们就可以定义一个枚举类来存放这些对象。

2. 为什么需要枚举类

如果不使用枚举类，我们想在一个类中定义星期一到星期天，就可能需要在类中使用常量来表示，实例如下：

  1. public class Weekday {
  2.     public static final int MONDAY = 1;
  3.     public static final int TUESDAY = 2;
  4.     public static final int WEDNESDAY = 3;
  5.     public static final int THURSDAY = 4;
  6.     public static final int FRIDAY = 5;
  7.     public static final int SATURDAY = 6;
  8.     public static final int SUNDAY = 7;
  9. }

使用一组常量表示一个枚举的集合，存在一个问题，编译器无法检测每个值的范围是否合法，例如：

  1. int day = 0; // 假设 day 的值为 0
  2. if (day == Weekday.MON) {
  3.     System.out.println("今天星期一");
  4. }

显然，0 不在这些常量值所表示的范围（1~7）内，但编译器不会给出提示，这样的编码是非常不推荐的。
当我们在开发中需要定义一组常量的时候，建议使用枚举类。接下来我们就来看如何定义枚举类。

3. 如何自定义枚举类

自定义枚举类有两种方式：

  1. 在 Java 5.0 之前，需要通过普通 Java 类的“改装”来定义一个枚举类；
  2. 在 Java 5.0 之后，可以使用 enum关键字来定义枚举类。

下面我们分别来看下这两种定义枚举类的方式。

3.1 Java 5.0 之前自定义枚举类

在 Java 5.0之前，想要定义一个枚举类较为繁琐，通常需要以下几个步骤：

  1. 定义一个 Java 普通类作为枚举类，定义枚举类的属性，使用private final修饰；
  2. 该类不提供外部实例化操作，因此将构造方法设置为私有，并初始化属性；
  3. 在类内部，提供当前枚举类的多个对象 ，使用public static final修饰；
  4. 提供常用的getter、setter或toString()方法。

下面我们定义一个用于表示性别的枚举类，并演示如何调用此枚举类，其具体实例如下：

  1. public class EnumDemo1 {
  3.     /**
  4.      * 性别枚举类
  5.      */
  6.     static class Sex {
  8.         // 定义常量
  9.         private final String sexName;
  11.         // 私有化构造器，不提供外部实例化
  12.         private Sex(String sexName) {
  13.             // 在构造器中为属性赋值
  14.             this.sexName = sexName;
  15.         }
  17.         public static final Sex MALE = new Sex("男");
  18.         public static final Sex FEMALE = new Sex("女");
  19.         public static final Sex UNKNOWN = new Sex("保密");
  21.         /**
  22.          * getter
  23.          */
  24.         public String getSexName() {
  25.             return sexName;
  26.         }
  28.         /**
  29.          * 重写toString方法，方便外部打印调试
  30.          */
  31.         @Override
  32.         public String toString() {
  33.             return "Sex{" +
  34.                     "sexName='" + sexName + '\'' +
  35.                     '}';
  36.         }
  37.     }
  39.     public static void main(String[] args) {
  40.         System.out.println(Sex.FEMALE.getSexName());
  41.         System.out.println(Sex.MALE.getSexName());
  42.         System.out.println(Sex.UNKNOWN.getSexName());
  43.     }
  45. }

运行结果：

  1. 女
  2. 男
  3. 保密

3.2 Java 5.0 之后自定义枚举类

在 Java 5.0 后，可以使用eunm关键字来定义一个枚举类，比较便捷，推荐大家使用这个方法来定义枚举类。
通常需要以下几个步骤：

  1. 使用enum关键字定义枚举类，这个类隐式继承自java.lang.Enum类；
  2. 在枚举类内部，提供当前枚举类的多个对象，多个对象之间使用逗号分割，最后一个对象使用分号结尾；
  3. 声明枚举类的属性和构造方法，在构造方法中为属性赋值；
  4. 提供 getter 方法，由于Enum类重写了 toString()方法，因此一般不需要我们自己来重写。

具体实例如下：

  1. public class EnumDemo2 {
  3.     public static void main(String[] args) {
  4.         Sex male = Sex.MALE;
  5.         // 打印 Sex 对象
  6.         System.out.println(male);
  7.         // 打印 getter方法的值
  8.         System.out.println(male.getSexName());
  9.         System.out.println(Sex.FEMALE.getSexName());
  10.         System.out.println(Sex.UNKNOWN.getSexName());
  11.     }
  13. }
  15. /**
  16.  * 使用 enum 关键字定义枚举类，默认继承自 Enum 类
  17.  */
  18. enum Sex {
  19.     // 1.提供当前枚举类的多个对象，多个对象之间使用逗号分割，最后一个对象使用分号结尾
  20.     MALE("男"),
  21.     FEMALE("女"),
  22.     UNKNOWN("保密");
  24.     /**
  25.      * 2.声明枚举类的属性
  26.      */
  27.     private final String sexName;
  29.     /**
  30.      * 3.编写构造方法，为属性赋值
  31.      */
  32.     Sex(String sexName) {
  33.         this.sexName = sexName;
  34.     }
  36.     /**
  37.      * 4.提供getter
  38.      */
  39.     public String getSexName() {
  40.         return sexName;
  41.     }
  42. }

运行结果：

  1. MALE
  2. 男
  3. 女
  4. 保密

4. Enum 类

java.lang.Enum类 是 Java 语言枚举类型的公共基类，我们使用enum关键字定义的枚举类，是隐式继承自Enum类的，下面我们来看一下Enum类的常用方法：

  • values()：返回枚举类型的对象数组。改方法可以很方便的遍历所有的枚举值；
  • valueOf()：可以把一个字符串转换为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”，如果不是，会抛出IllegalArguementException；
  • toString()：返回当前枚举类对象常量的名称。

这 3 个方法使用起来比较简单，因此我们写在一个实例中，代码如下：

  1. public class EnumDemo3 {
  3.     public static void main(String[] args) {
  4.         Sex male = Sex.MALE;
  5.         System.out.println("调用 toString() 方法：");
  6.         System.out.println(male.toString());
  8.         System.out.println("调用 values() 方法：");
  9.         Sex[] values = Sex.values();
  10.         for (Sex value : values) {
  11.             System.out.println(value);
  12.         }
  14.         System.out.println("调用 valueOf() 方法：");
  15.         Sex male1 = Sex.valueOf("MALE");
  16.         System.out.println(male1);
  17.     }
  19. }
  21. /**
  22.  * 使用 enum 关键字定义枚举类，默认继承自 Enum 类
  23.  */
  24. enum Sex {
  25.     // 1.提供当前枚举类的多个对象，多个对象之间使用逗号分割，最后一个对象使用分号结尾
  26.     MALE("男"),
  27.     FEMALE("女"),
  28.     UNKNOWN("保密");
  30.     /**
  31.      * 2.声明枚举类的属性
  32.      */
  33.     private final String sexName;
  35.     /**
  36.      * 3.编写构造方法，为属性赋值
  37.      */
  38.     Sex(String sexName) {
  39.         this.sexName = sexName;
  40.     }
  42.     // 提供 getter 和 setter
  44.     public String getSexName() {
  45.         return sexName;
  46.     }
  47. }

运行结果：

  1. 调用 toString() 方法：
  2. MALE
  3. 调用 values() 方法：
  4. MALE
  5. FEMALE
  6. UNKNOWN
  7. 调用 valueOf() 方法：
  8. MALE

值得注意的是，当调用valuOf()方法时，我们传递的对象的“名字”，在枚举类中并不存在，此时会抛出运行时异常：IllegalArgumentException，实例如下：

  1. public class EnumDemo3 {
  3.     public static void main(String[] args) {
  4.         System.out.println("调用 valueOf() 方法：");
  5.         Sex male1 = Sex.valueOf("MALE1");
  6.         System.out.println(male1);
  7.     }
  9. }
  11. /**
  12.  * 使用 enum 关键字定义枚举类，默认继承自 Enum 类
  13.  */
  14. enum Sex {
  15.     // 1.提供当前枚举类的多个对象，多个对象之间使用逗号分割，最后一个对象使用分号结尾
  16.     MALE("男"),
  17.     FEMALE("女"),
  18.     UNKNOWN("保密");
  20.     /**
  21.      * 2.声明枚举类的属性
  22.      */
  23.     private final String sexName;
  25.     /**
  26.      * 3.编写构造方法，为属性赋值
  27.      */
  28.     Sex(String sexName) {
  29.         this.sexName = sexName;
  30.     }
  32.     // 提供 getter 和 setter
  34.     public String getSexName() {
  35.         return sexName;
  36.     }
  37. }

运行结果：

  1. 调用 valueOf() 方法：
  2. Exception in thread "main" java.lang.IllegalArgumentException: No enum constant Sex.MALE1
  3.     at java.base/java.lang.Enum.valueOf(Enum.java:273)
  4.     at Sex.valueOf(EnumDemo3.java:17)
  5.     at EnumDemo3.main(EnumDemo3.java:8)

5. 小结

通过本小节的学习，我们知道了枚举类就是一个可以表示枚举的类，当一个类的对象只有有限个、确定个的时候，我们就可以定义一个枚举类来存放这些对象。使用枚举类可以规避编译器无法检测每个值的范围是否合法的问题。自定义枚举类可以有两种方式，更推荐使用enum关键字来定义枚举类。所有通过enum关键字定义的枚举类都继承自java.lang.Enum类，要了解该类的常用方法的使用。