从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​​语句中。

‍

本文涉及代码已上传至：

Gitee：01.JavaSE/05.OOP/08.enum · 小林/LearnJava - 码云 - 开源中国 (opens new window)

GitHub：LearnJava/01.JavaSE/05.OOP at master · Peter-JXL/LearnJava (opens new window)

在GitHub上编辑此页 (opens new window)
上次更新: 2023/1/23 17:06:18
Java多版本配置
static关键字

← static关键字→

Theme by Vdoing | Copyright © 2022-2023 粤ICP备2022067627号-1 粤公网安备 44011302003646号