从 01 开始
2022-11-28
目录

枚举类

# 枚举类

声明：本博客主要是根据廖雪峰老师的博客，并结合自己的经历敲了一遍代码而得，参考 枚举类 - 廖雪峰的官方网站 (opens new window)

# 引出枚举类

我们经常需要定义并使用常量，在 Java 中可以通过 static final 来定义常量。例如在数学运算中，涉及到圆的需要用到 π，我们可以定义一个 PI 常量，这样用到 PI 的地方就可以直接使用常量。

public static final double PI = 3.14159;
double area = r * r * PI; //计算圆的面积
1
2

有时候，我们可能需要定义多个常量，并且这些常量是互相关联的：例如定义周一到周日这 7 个常量。

我们可以定义一个专门存储常量的类（在笔者工作中就经常遇到这种存储常量的类），里面定义 7 个不同的 int：

public class Weekday {
    public static final int SUN = 0;
    public static final int MON = 1;
    public static final int TUE = 2;
    public static final int WED = 3;
    public static final int THU = 4;
    public static final int FRI = 5;
    public static final int SAT = 6;
}
1
2
3
4
5
6
7
8
9

上面只是举个例子，举个实际例子：笔者在工作中，定义的常量有很多的，例如是否生产模式，数据库类型，错误代码等。

public class Constants{
    private Constants(){
	//禁用构造函数
    }

    public static boolen PRODUCT_MODE=true;
    public static int DB_TYPE = "ORACLE";
    //…………还有很多常量定义，省略
}
1
2
3
4
5
6
7
8
9

使用这些常量来表示一组枚举值的时候，有一个严重的问题就是，编译器无法某个值是否属于常量类的，例如：

if (7 == Weekday.MON) {
  
}
1
2
3

上述代码编译和运行均不会报错，但存在两个问题：

  • Weekday类 定义的常量范围是 0~6，并不包含 7，编译器无法检查不在枚举中的 int 值，这种比较是不合理的
  • 定义的常量仍可与其他变量比较（因为本质上就是基本数据类型），但其用途并非是判断星期几

# 枚举类的定义和使用

为了让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用 enum 来定义枚举类：

enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}
1
2
3

然后使用枚举类里的变量：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day == Weekday.SAT || day == Weekday.SUN) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10

完整代码如下

public class LearnEnum {
  public static void main(String[] args) {
    WeekDay day = WeekDay.SUN;
    if (day == WeekDay.SUN || day == WeekDay.SAT){
      System.out.println("holiday!");
    }else{
      System.out.println("Work day");
    }
  }
}


enum WeekDay{
  SUN, MON, TUE, WED, THU, FRI, SAT
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# enum 的本质

enum 本质上就是常量类，只不过换了种写法，其实现方式也是相当于定义了一个类；

但它有以下几个特点：

  • 定义的 enum 类型继承自 java.lang.Enum，但使用了 final 修饰符，无法被继承，也无法被 new 操作符创建 enum 的实例；
  • 定义的每个实例都是引用类型的唯一实例；

我们可以试着编译后，反编译看其源码。在前面我们定义和使用枚举类的时候，编译会有 2 个 class 文件，我们反编译 WeekDay.class 即可。

> javap -c WeekDay.class
Compiled from "LearnEnum.java"
final class WeekDay extends java.lang.Enum<WeekDay> { // 继承自Enum，标记为final class

  // 每个实例均为全局唯一:
  public static final WeekDay SUN;
  public static final WeekDay MON;
  public static final WeekDay TUE;
  public static final WeekDay WED;
  public static final WeekDay THU;
  public static final WeekDay FRI;
  public static final WeekDay SAT;

  // private构造方法，确保外部无法调用new操作符:
    private Color() {}
..............
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

更多 Javap 的说明，可以参考：通过 javap 命令分析 java 汇编指令 - 简书 (opens new window)

编译后的 enum 类和普通 class 并没有任何区别。但是我们自己无法按定义普通 class 那样来定义 enum，必须使用 enum 关键字，别问为什么，这是 Java 语法规定的 😑。

# 使用枚举类的好处

和 int 定义的常量相比，使用 enum 定义枚举有如下好处：

首先，enum 常量本身带有类型信息，即 Weekday.SUN 类型是 Weekday，编译器会自动检查出类型错误。例如，下面的语句不可能编译通过：

public class LearnEnum2 {
  public static void main(String[] args) {
    int day = 1;
    if (day == WeekDay.SUN){}
  }
}


enum WeekDay{
  SUN, MON, TUE, WED, THU, FRI, SAT
}
1
2
3
4
5
6
7
8
9
10
11

编译会报错，因为这相当于用一个 int 类型 和 一个 class 类型比较，是不行的：

javac LearnEnum2.java
LearnEnum2.java:4: 错误: 二元运算符 '==' 的操作数类型错误
    if (day == WeekDay.SUN){
            ^
  第一个类型:  int
  第二个类型: WeekDay
1 个错误
1
2
3
4
5
6
7

其次，不可能引用到非枚举的值

public class LearnEnum2 {
  public static void main(String[] args) {
    int day = 1;
    WeekDay day2 =WeekDay.fuk;
  }
}


enum WeekDay{
  SUN, MON, TUE, WED, THU, FRI, SAT
}
1
2
3
4
5
6
7
8
9
10
11

因为无法通过编译：

> javac LearnEnum2.java
LearnEnum2.java:4: 错误: 找不到符号
    WeekDay day2 =WeekDay.fuk;
                         ^
  符号:   变量 fuk
  位置: 类 We
1
2
3
4
5
6

最后，不同类型的枚举不能互相比较或者赋值。例如，定义了一个 Color 的枚举类，但不能给一个 Weekday 枚举类型的变量赋值为 Color 枚举类型的值：

public class LearnEnum2 {
  public static void main(String[] args) {
    WeekDay day3 =Color.RED;
  }
}

enum WeekDay{ SUN, MON, TUE, WED, THU, FRI, SAT}
enum Color {  RED, GREEN, BULE}
1
2
3
4
5
6
7
8

因为类型不符，虽然都是继承自 enum，但本质上是不同的类，相互赋值肯定不行：

javac LearnEnum2.java
LearnEnum2.java:4: 错误: 不兼容的类型: Color无法转换为WeekDay
    WeekDay day3 =Color.RED;
                       ^
1 个错误
1
2
3
4
5

enum 的机制使得编译器可以在编译期自动检查出所有可能的潜在错误，降低了程序在运行过程中出错的可能性。

# enum 类型的比较和实例方法

使用 enum 定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用 equals() 方法，如果使用 == 比较（例如 String），它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用 equals() 方法。

但 enum 类型可以例外，这是因为 enum 类型的每个常量在 JVM 中只有一个唯一实例，所以可以直接用 == 比较，我们在刚刚已经使用过了：

if (day == Weekday.FRI) { // ok!
}
if (day.equals(Weekday.SUN)) { // ok, but more code!
}
1
2
3
4

因为 enum是一个 class，每个枚举的值都是 class实例，因此，这些实例有一些方法：

# name()

返回常量名，例如：

String s = Weekday.SUN.name(); // "SUN"
1

# ordinal()

返回定义的常量的顺序，从 0 开始计数，例如：

int n = Weekday.MON.ordinal(); // 1
1

改变枚举常量定义的顺序就会导致 ordinal()返回值发生变化。例如：

enum WeekDay{
  SUN, MON, TUE, WED, THU, FRI, SAT
}

enum WeekDay2{
  MON, TUE, WED, THU, FRI, SAT, SUN
}
1
2
3
4
5
6
7

两个 MON 的 ordinal 就是不同的。如果在代码中编写了类似 if(x.ordinal()==1) 这样的语句，就要保证 enum 的枚举顺序不能变。新增的常量必须放在最后。

# 给枚举类型指定 int 值

Weekday 的枚举常量如果要和 int 转换，使用 ordinal() 不是非常方便？比如这样写：

String task = Weekday.MON.ordinal() + "/ppt";
1

但是，如果不小心修改了枚举的顺序，编译器是无法检查出这种逻辑错误的。

要编写健壮的代码，就不要依靠 ordinal()的返回值。因为 enum本身是 class，所以我们可以定义 private的构造方法，并且，给每个枚举常量添加字段：

// enum
public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);

    public final int dayValue;

    private Weekday(int dayValue) {
        this.dayValue = dayValue;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这样就无需担心顺序的变化，新增枚举常量时，也需要指定一个 int 值。

注意：枚举类的字段也可以是非 final 类型，即可以在运行期修改，但是不推荐这样做！

# 重写 toString 方法

默认情况下，对枚举常量调用 toString() 会返回和 name() 一样的字符串。但是，toString() 可以被覆写，而 name() 则不行。我们可以给 Weekday 添加 toString() 方法：

// enum
public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Today is " + day + ". Work at home!");
        } else {
            System.out.println("Today is " + day + ". Work at office!");
        }
    }
}

enum Weekday {
    MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");

    public final int dayValue;
    private final String chinese;

    private Weekday(int dayValue, String chinese) {
        this.dayValue = dayValue;
        this.chinese = chinese;
    }

    @Override
    public String toString() {
        return this.chinese;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行：

javac LearnEnum5String.java -encoding utf8 
java LearnEnum5String
Today is 星期日. Work At Home!
1
2
3

覆写 toString() 的目的是在输出时更有可读性。

注意：判断枚举常量的名字，要始终使用 name()方法，绝不能调用 toString()！

# switch

最后，枚举类可以应用在 switch语句中。因为枚举类天生具有类型信息和有限个枚举常量，所以比 int、String类型更适合用在 switch语句中：

// switch
public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        switch(day) {
        case MON:
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("Today is " + day + ". Work at office!");
            break;
        case SAT:
        case SUN:
            System.out.println("Today is " + day + ". Work at home!");
            break;
        default:
            throw new RuntimeException("cannot process " + day);
        }
    }
}

enum Weekday {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

加上 default 语句，可以在漏写某个枚举常量时自动报错，从而及时发现错误。

# 小结

Java 使用 enum定义枚举类型，它被编译器编译为 final class Xxx extends Enum { … }；

enum 是一个 class，每个枚举的值都是 class 实例。这对理解 enum 很重要。

通过 name()获取常量定义的字符串，注意不要使用 toString()；

通过 ordinal()返回常量定义的顺序（无实质意义）；

可以为 enum编写构造方法、字段和方法

enum的构造方法要声明为 private，字段强烈建议声明为 final；

enum适合用在 switch语句中。

上次更新: 2024/9/30 20:09:39
Java 多版本配置
static 关键字

← static 关键字→

最近更新
01
学点统计学：轻松识破一本正经的胡说八道
06-05
02
2025 年 5 月记
05-31
03
《贫穷的本质》很棒，但可能不适合你
05-27
更多文章>
Theme by Vdoing | Copyright © 2022-2025 | 粤 ICP 备 2022067627 号 -1 | 粤公网安备 44011302003646 号 | 点击查看十年之约