Java枚举类的基本使用

旧城等待， 2024-03-23 13:00 48阅读 0赞

## 一、枚举类的引入 ##

### 1.先看一个需求 ###

*  要求创建季节（Season）对象，请设计并完成

public class Enumeration01 {
        public static void main(String[] args) {
            //使用
            Season spring = new Season("春天", "温暖");
            Season summer = new Season("夏天", "炎热");
            Season autumn = new Season("秋天", "凉爽");
            Season winter = new Season("冬天", "寒冷");
    
            //错误示例
            //autumn.setName("XXX");
            //autumn.setDesc("非常的热..");
    //因为对于季节而已，它们的对象(具体值)，是固定的四个，不会有更多
    //这个设计类的思路，不能体现季节是固定的四个对象
    //因此，这样的设计不好===> 枚举类[枚: 一个一个。 举： 例举。 即把具体的对象一个一个例举出来的类，就称为枚举类]
    //Season other = new Season("白天", "光明");
    
        }
    }
    
    class Season {//类
        private String name;
        private String desc;//描述
    
        public Season(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    }

### 2.分析问题 ###

*  创建的Season对象有如下特点

1.季节的值是有限的几个值(spring, summer, autumn, winter)

2.只读，不需要修改。

### 3.解决方案---枚举 ###

*  枚举对应英文(enumeration, 简写 enum)
 *  枚举是一组常量的集合。
 *  可以理解为：枚举属于一种特殊的类，里面只包含一组有限的特定的对象。

## 二、枚举类 ##

### 1.枚举的两种实现方式 ###

*  自定义类实现枚举
 *  使用 enum 关键字实现枚举

#### 1.1 自定义类实现枚举 ####

（1）应用案例

1.  不需要提供setXxx方法，因为枚举对象值通常为只读。
2.  对枚举 对象/属性 使用final + static共同修饰，实现底层优化。
3.  枚举对象名通常使用全部大写，常量的命名规范。
4.  枚举对象根据需要，也可以有多个属性。

public class Enumeration02 {
        public static void main(String[] args) {
    
            System.out.println(Season.SPRING);
            System.out.println(Season.SUMMER);
            System.out.println(Season.AUTUMN);
            System.out.println(Season.WINTER);
    
        }
    }
    
    //演示自定义枚举实现
    class Season {//类
        private String name;
        private String desc;//描述
    
        //定义了四个对象，固定值
        public static final Season SPRING = new Season("春天", "温暖");
        public static final Season SUMMER = new Season("夏天", "炎热");
        public static final Season AUTUMN = new Season("秋天", "凉爽");
        public static final Season WINTER = new Season("冬天", "寒冷");
    
    
        //1. 将构造器私有化，目的是防止 直接 new
        //2. 去掉 setXxx 方法，防止属性被修改
        //3. 在 Season 内部，直接创固定的对象
        //4. 优化下：可以加入 final 修饰符
        private Season(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
            return name;
        }
    
        public String getDesc() {
            return desc;
        }
    
        @Override
        public String toString() {
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

![98825efeb71941a6a1f8e50b41668a86.png][]

（2）特点

1.  构造器私有化
2.  本类内部创建一组对象【四个： 春夏秋冬】
3.  对外暴露对象（通过为对象添加 `public final static` 修饰符）
4.  可以提供 `get` 方法，但是不要提供 `set` 方法

#### 1.2 enum关键字实现枚举 ####

(1)快速入门

*  说明：使用 `enum` 来实现前面的枚举案例，主要体会和自定义类实现枚举不同的地方。

public class Enumeration03 {
        public static void main(String[] args) {
            System.out.println(Season.SPRING);
            System.out.println(Season.SUMMER);
            System.out.println(Season.AUTUMN);
            System.out.println(Season.WINTER);
        }
    }
    
    //演示enum关键字来实现枚举类
    enum Season {//类
        //如果使用 enum 来实现枚举类
        //1. 使用 enum 来替代 class
        //2.  public static final Season SPRING = new Season("春天", "温暖"); 等价于
        // SPRING("春天", "温暖") 解读：常量名(实参列表)
        //3. 如果有多个常量(对象), 使用 "," 间隔
        //4. 如果使用 enum 来实现枚举，要求将定义常量对象，写在最前面
        SPRING("春天", "温暖"),
        SUMMER("夏天", "炎热"),
        AUTUMN("秋天", "凉爽"),
        WINTER("冬天", "寒冷");
    
        private String name;
        private String desc;//描述
    
        private Season(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
            return name;
        }
    
        public String getDesc() {
            return desc;
        }
    
        @Override
        public String toString() {
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

![20f613804cb8465ba37dd2460bb7569e.png][]

(2)注意事项

1.当我们使用 `enum` 关键字开发一个枚举类时，默认会继承 `Enum` 类， 而且是一个 `final` 类。

*  证明如下：使用 `javap` （**反编译**）工具来演示

![8dc13a5dd0a74761af6a6a8ae3f7bb09.png][]

2.传统的 public static final Season2 SPRING = new Season2("春天", "温暖"); 简化成： SPRING("春天", "温暖")， 这里必须知道，它调用的是哪个构造器.。

3.如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略。

![86811911753c4c8384dacc71e1aefcb1.png][]

4.当有多个枚举对象时，使用“`,`”间隔，最后有一个分号“`;`”结尾

5.枚举对象必须放在枚举类的行首

![88e7640d51ba49478de16551fef6f9fc.png][]

## 三、案例练习 ##

*  判断下面代码是否正确，并说明其表示的含义

enum Gender{ 
    	BOY, GIRL; //这里其实就是调用 Gender 类的无参构造器
    }

1.  上面语法是正确的
2.  有一个枚举类 `Gender`， 没有属性。
3.  有两个枚举对象 `BOY， GIRL`，使用的无参构造器创建。

*  下面代码输出什么？

public class EnumExercise01 {
        public static void main(String[] args) {
            Gender boy = Gender.BOY;
            Gender boy2 = Gender.BOY;
            System.out.println(boy);//输出BOY 
    
    //本质就是调用 Gender 的父类Enum的 toString()，如下所示
    //        public String toString() {
    //            return name;
    //        }
    
            System.out.println(boy == boy2);  //true
        }
    }
    enum Gender{ //父类 Enum 中的toString
        BOY , GIRL;
    }

## 四、 enum 常用方法 ##

### 1.介绍 ###

*  说明：使用关键字 `enum` 时，会隐式继承 `Enum` 类，这样就可以使用 `Enum` 类相关的方法。

![f52dd48653f0403692e97fcbb7f3d471.png][]

### 2.演示 ###

*  `toString`：Enum 类已经重写过了，返回的是当前对象名，子类可以重写该方法，用于返回对象的属性信息
 *  `name`：返回当前对象名（常量名），子类中不能重写

public class EnumMethod {
        public static void main(String[] args) {
        
        	//使用Season 枚举类，来演示各种方法
            Season autumn = Season.AUTUMN;
            //输出枚举对象的名字
            System.out.println(autumn.name());   //AUTUMN
           }
    }
    
    //演示enum关键字来实现枚举类
    enum Season {//类
        SPRING("春天", "温暖"),
        SUMMER("夏天", "炎热"),
        AUTUMN("秋天", "凉爽"),
        WINTER("冬天", "寒冷"); 
    
        private String name;
        private String desc;//描述
    
        private Season() {//无参构造器
        }
    
        private Season(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
            return name;
        }
    
        public String getDesc() {
            return desc;
        }
    
        @Override
        public String toString() {
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

*  `ordinal`：返回当前对象的位置号，默认从 `0` 开始

//ordinal() 输出的是该枚举对象的次序/编号，从0开始编号
    //AUTUMN 枚举对象是第三个，因此输出 2
    System.out.println(autumn.ordinal());//2

*  `values`：返回当前枚举类中所有的常量

//含有定义的所有枚举对象
    Season[] values = Season.values();
    System.out.println("===遍历取出枚举对象(增强for)====");
    for (Season season: values) {//增强for循环
        System.out.println(season);
    }

![b65badc28cd049f6a8c089beb6b58ba3.png][]

*  `valueOf`：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！

//valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
    //执行流程：
    //1. 根据你输入的 "AUTUMN" 到 Season2的枚举对象去查找
    //2. 如果找到了，就返回，如果没有找到，就报错
    Season autumn1 = Season.valueOf("AUTUMN");
    System.out.println("autumn1=" + autumn1);
    System.out.println(autumn == autumn1);

![32a0d64d7b604204a8ffd474e35021e8.png][]

*  `compareTo`：比较两个枚举常量，比较的就是编号，就是上面 `ordinal` 的编号

//解读：
    //1. 就是把 Season.AUTUMN 枚举对象的编号 和 Season.SUMMER 枚举对象的编号比较
    //2. 源码：Season.AUTUMN的编号[2] - Season2.SUMMER的编号[1]
    /*
    public final int compareTo(E o) {
    
        return self.ordinal - other.ordinal;
    }
    Season2.AUTUMN的编号[2] - Season2.SUMMER的编号[1]
     */
    System.out.println(Season.AUTUMN.compareTo(Season.SUMMER));//1

## 五、enum实现接口 ##

1.  使用 `enum` 关键字后，就不能再继承其它类了，因为 `enum` 会隐式继承 `Enum`，而 Java 是单继承机制。
2.  枚举类和普通类一样，可以实现接口，如下形式。

enum 类名 implements 接口1, 接口2 { }

interface IPlaying {
        public void playing();
    }
    
    enum Music implements IPlaying {
    
        CLASSICMUSIC;
        
        @Override
        public void playing() {
            System.out.println("播放好听的音乐...");
        }
    }
    
    public class EnumDetail {
        public static void main(String[] args) {
            Music.CLASSICMUSIC.playing();
        }
    }

![e16c0a2cb5be4875a4c22b4f3a13f8a3.png][]

[98825efeb71941a6a1f8e50b41668a86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ba16440e17064ebb9d8b43a23f6a54dd.png
[20f613804cb8465ba37dd2460bb7569e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/32084f199474495ba25f279a4bc7dde4.png
[8dc13a5dd0a74761af6a6a8ae3f7bb09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/aca82217577c4078b02ae353be7ad369.png
[86811911753c4c8384dacc71e1aefcb1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/f652c9a3b5614b25abc4c3950b0d0322.png
[88e7640d51ba49478de16551fef6f9fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/dafbce382a6e493cae015a8ed7e0ff1c.png
[f52dd48653f0403692e97fcbb7f3d471.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/eaacebb6104a4d698b3ddd37f29fd0a4.png
[b65badc28cd049f6a8c089beb6b58ba3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/57cdd4cf0136494880580452bc546db4.png
[32a0d64d7b604204a8ffd474e35021e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/75aba7ac109842bda6f2beac238fde98.png
[e16c0a2cb5be4875a4c22b4f3a13f8a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/f63342e9032a4d59850af115d0c21682.png