从 01 开始 从 01 开始
首页
  • 📚 计算机基础

    • 计算机简史
    • 数字电路
    • 计算机组成原理
    • 操作系统
    • Linux
    • 计算机网络
    • 数据库
    • 编程工具
    • 装机
  • 🎨 前端

    • Node
  • JavaSE
  • Java 高级
  • JavaEE

    • 构建、依赖管理
    • Ant
    • Maven
    • 日志框架
    • Junit
    • JDBC
    • XML-JSON
  • JavaWeb

    • 服务器软件
    • 环境管理和配置管理-科普篇
    • Servlet
  • Spring

    • Spring基础
  • 主流框架

    • Redis
    • Mybatis
    • Lucene
    • Elasticsearch
    • RabbitMQ
    • MyCat
    • Lombok
  • SpringMVC

    • SpringMVC 基础
  • SpringBoot

    • SpringBoot 基础
  • Windows 使用技巧
  • 手机相关技巧
  • 最全面的输入法教程
  • 最全面的浏览器教程
  • Office
  • 图片类工具
  • 效率类工具
  • 最全面的 RSS 教程
  • 码字工具
  • 各大平台
  • 校招
  • 五险一金
  • 职场规划
  • 关于离职
  • 杂谈
  • 自媒体
  • 📖 读书

    • 读书工具
    • 走进科学
  • 🌍 英语

    • 从零开始学英语
    • 英语兔的相关视频
    • Larry 想做技术大佬的相关视频
  • 🏛️ 政治

    • 反腐
    • GFW
    • 404 内容
    • 审查与自我审查
    • 互联网
    • 战争
    • 读书笔记
  • 💰 经济

    • 关于税
    • 理财
  • 💪 健身

    • 睡眠
    • 皮肤
    • 口腔健康
    • 学会呼吸
    • 健身日志
  • 🏠 其他

    • 驾驶技能
    • 租房与买房
    • 厨艺
  • 电影

    • 电影推荐
  • 电视剧
  • 漫画

    • 漫画软件
    • 漫画推荐
  • 游戏

    • Steam
    • 三国杀
    • 求生之路
  • 小说
  • 关于本站
  • 关于博主
  • 打赏
  • 网站动态
  • 友人帐
  • 从零开始搭建博客
  • 搭建邮件服务器
  • 本站分享
  • 🌈 生活

    • 2022
    • 2023
    • 2024
    • 2025
  • 📇 文章索引

    • 文章分类
    • 文章归档

晓林

程序猿,自由职业者,博主,英语爱好者,健身达人
首页
  • 📚 计算机基础

    • 计算机简史
    • 数字电路
    • 计算机组成原理
    • 操作系统
    • Linux
    • 计算机网络
    • 数据库
    • 编程工具
    • 装机
  • 🎨 前端

    • Node
  • JavaSE
  • Java 高级
  • JavaEE

    • 构建、依赖管理
    • Ant
    • Maven
    • 日志框架
    • Junit
    • JDBC
    • XML-JSON
  • JavaWeb

    • 服务器软件
    • 环境管理和配置管理-科普篇
    • Servlet
  • Spring

    • Spring基础
  • 主流框架

    • Redis
    • Mybatis
    • Lucene
    • Elasticsearch
    • RabbitMQ
    • MyCat
    • Lombok
  • SpringMVC

    • SpringMVC 基础
  • SpringBoot

    • SpringBoot 基础
  • Windows 使用技巧
  • 手机相关技巧
  • 最全面的输入法教程
  • 最全面的浏览器教程
  • Office
  • 图片类工具
  • 效率类工具
  • 最全面的 RSS 教程
  • 码字工具
  • 各大平台
  • 校招
  • 五险一金
  • 职场规划
  • 关于离职
  • 杂谈
  • 自媒体
  • 📖 读书

    • 读书工具
    • 走进科学
  • 🌍 英语

    • 从零开始学英语
    • 英语兔的相关视频
    • Larry 想做技术大佬的相关视频
  • 🏛️ 政治

    • 反腐
    • GFW
    • 404 内容
    • 审查与自我审查
    • 互联网
    • 战争
    • 读书笔记
  • 💰 经济

    • 关于税
    • 理财
  • 💪 健身

    • 睡眠
    • 皮肤
    • 口腔健康
    • 学会呼吸
    • 健身日志
  • 🏠 其他

    • 驾驶技能
    • 租房与买房
    • 厨艺
  • 电影

    • 电影推荐
  • 电视剧
  • 漫画

    • 漫画软件
    • 漫画推荐
  • 游戏

    • Steam
    • 三国杀
    • 求生之路
  • 小说
  • 关于本站
  • 关于博主
  • 打赏
  • 网站动态
  • 友人帐
  • 从零开始搭建博客
  • 搭建邮件服务器
  • 本站分享
  • 🌈 生活

    • 2022
    • 2023
    • 2024
    • 2025
  • 📇 文章索引

    • 文章分类
    • 文章归档
  • JavaSE

    • 我的 Java 学习路线
    • 安装 Java
    • Java 数据类型

    • Java 多版本配置
    • 面向对象

      • 枚举类
        • 引出枚举类
        • 枚举类的定义和使用
        • enum 的本质
        • 使用枚举类的好处
        • enum 类型的比较和实例方法
        • switch
        • 小结
      • static 关键字
      • classpath:JVM 查找类的机制
      • 包:Java 组织类的方式
      • jar 包
      • class 版本
      • 抽象类
      • 接口
      • 访问性修饰符
      • 非访问性修饰符
      • 内部类
    • Java 核心类

    • IO

    • Java 与时间

    • 异常处理

    • 哈希和加密算法

    • Java8 新特性

    • 网络编程

  • JavaSenior

  • JavaEE

  • JavaWeb

  • Spring

  • 主流框架

  • SpringMVC

  • SpringBoot

  • Java
  • JavaSE
  • 面向对象
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 关键字

← Java 多版本配置 static 关键字→

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