Java枚举

最新推荐文章于 2024-06-17 11:16:12 发布

TJU@第一炼丹师

最新推荐文章于 2024-06-17 11:16:12 发布

阅读量1.8k

点赞数 22

文章标签： java 开发语言数据库

本文链接：https://blog.csdn.net/lmd187/article/details/135672681

版权

一、为什么需要枚举?

对于某些有固定几个对象的类，比如说星期，月份，季节等等。它们可定义的对象数量是一定的，且不可更改。传统的定义类的方式显然无法满足需求。

二、枚举介绍

枚举全称Enumeration [ˌ ɪnuːməˈ reɪʃn]，简称Enum或者enum。枚举是一组常量的集合。枚举类属于一种特殊的类，里面只包含一组有限的特定的对象。枚举的出现可以解决上述的问题。

三、枚举的实现方式

1.自定义枚举 :

步骤 :

①将自定义类的构造器私有化，使其不能被随随便便地new出对象。

②取消类中提供的setXxx方法，仅保留getXxx方法，因为“枚举类”对象仅可读，不能随便修改对于对象的描述。

③直接在自定义类中创建一组对象，使用static + final的组合实现底层优化。并且要对外暴露这组对象，因此要添加public修饰符来公开这组对象。

④枚举对象名通常全部大写，以符合常量的定义规范。

⑤枚举对象根据需要，也可以有多个属性。

package com.lmdedu.enum_;

/**
 * @author TJU第一炼丹师
 * @date 2024-01-18 14:07:58
 */
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;
    //1、私有化构造器
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    //2、去掉setter,只保留getter
    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
    //3、直接在自定义类中创建一组对象，使用static + final的组合实现底层优化。
    // 并且要对外暴露这组对象，因此要添加public修饰符来公开这组对象。
    //4、枚举对象名通常全部大写，以符合常量的定义规范。
    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("冬天","寒冷");
    //toString
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

2.enum关键字 :

步骤 :

①将自定义类的构造器私有化，使其不能被随随便便地new出对象。

②取消类中提供的setXxx方法，仅保留getXxx方法，因为“枚举类”对象仅可读，不能随便修改对于对象的描述。

③在定义类时，使用enum关键字替换掉class关键字。enum关键字用于声明枚举类。

④创建枚举类对象时，不再和自定义枚举一样使用“public + static + final”关键字的组合形式，而是直接“常量名（形参列表）”搞定。（实际调用的仍然是构造器）。声明枚举对象时，必须明确调用的是哪个构造器。

SPRING("春天","温暖"),SUMMER("夏天","炎热"),
           AUTUMN("秋天","凉爽"),WINTER("冬天","寒冷");
//等价于

    public static final Season SPRING = new Season2("春天","温暖");
    public static final Season SUMMER = new Season2("夏天","炎热");
    public static final Season AUTUMN = new Season2("秋天","凉爽");
    public static final Season WINTER = new Season2("冬天","寒冷");

⑤如果有多个常量对象，使用逗号','间隔即可。最后一个常量后加分号。

⑥如果使用enum来实现枚举，语法规定常量必须写在类的最前面，否则报错。

package com.lmdedu.enum_;

/**
 * @author TJU第一炼丹师
 * @date 2024-01-18 14:20:58
 */
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关键字来实现枚举类
//1、在定义类时，使用enum关键字替换掉class关键字。enum关键字用于声明枚举类。
enum Season2 {
    //创建枚举类对象时，不再和自定义枚举一样使用“public + static + final”关键字的组合形式，
    // 而是直接“常量名（形参列表）”搞定。（实际调用的仍然是构造器）。声明枚举对象时，必须明确调用的是哪个构造器。
    //如果使用enum来实现枚举，语法规定常量必须写在类的最前面，否则报错。
    //如果有多个常量对象，使用逗号','间隔即可。最后一个常量后加分号。
    SPRING("春天","温暖"),SUMMER("夏天","炎热"),
           AUTUMN("秋天","凉爽"),WINTER("冬天","寒冷");

    private String name;
    private String desc;
    //1、私有化构造器
    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    //2、去掉setter,只保留getter
    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
//    public static final Season SPRING = new Season2("春天","温暖");
//    public static final Season SUMMER = new Season2("夏天","炎热");
//    public static final Season AUTUMN = new Season2("秋天","凉爽");
//    public static final Season WINTER = new Season2("冬天","寒冷");
    //toString
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

四、枚举类补充

1.如果使用了enum关键字来声明枚举类，则声明的枚举类默认继承了Enum类，并且底层默认是一个final类。

2.对于“1.”的证明 :

①通过Ctrl + H/h快捷键快速查看继承关系，如下图所示 :

②通过javap命令来证明，如下图所示 :

3.若使用无参构造器创建枚举对象，则后面的形参列表和括号都可以省略。如下图所示 :

4.IDEA中直接创建枚举类的方式 :

与接口类似，也是先按照正常创建类的流程来走，如下图所示：

选择“Java Class”之后，在弹出的小窗口中选择Enum，然后输入枚举类类名，回车即可，如下图所示 :

创建好枚举类之后，可以看到枚举类的图标中间是一个“E”字母，如下图所示 :

五、关于枚举类的父类——Enum类

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

1.基本介绍 :

2.常用方法 :

①总览

②演示 :

演示Ⅰ：name方法——得到当前枚举常量的名称。（建议优先使用toString方法）

package knowledge.enum_.introduction;
 
public enum Season {
    SPRING("spring", "warm"), SUMMER("summer", "hot"),
    AUTUMN("autumn", "cool"), WINTER("winter", "cold");
 
    private Season() {}
 
    private String name;
    private String portrait;
 
    private Season(String name, String portrait) {
        this.name = name;
        this.portrait = portrait;
    }
 
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", portrait='" + portrait + '\'' +
                '}';
    }
}
 
class Test2 {
    public static void main(String[] args) {
        //1.name
        Season season = Season.SPRING;
        Season season2 = Season.AUTUMN;
        System.out.println("season's name = " + season.name());
        System.out.println("season2's name = " + season2.name());
    }
}

演示Ⅱ：ordinal方法——返回当前枚举常量对应的编号/次序。（即在枚举类中的定义顺序，第一个枚举常量默认从0开始编号）

Season类代码不变，Test类代码如下 :

class Test2 {
    public static void main(String[] args) {
        //2.ordinal
        Season season = Season.SPRING;
        Season season2 = Season.AUTUMN;
        System.out.println("season's index = " + season.ordinal());
        System.out.println("season2's index = " + season2.ordinal());
    }
}

演示Ⅲ：values方法——可以返回一个当前枚举类型的数组，里面包含了当前枚举类中定义的所有枚举对象。

PS : values方法是隐藏的底层方法，可以通过javap命令反编译找到，如下图所示 :

Season类代码不变，Test类代码如下 :

class Test2 {
    public static void main(String[] args) {
        //3.values
        Season[] seasons = Season.values();//数组
        for (Season season : seasons) {//增强for循环
            System.out.println(season);
        }
    }
}

//关于如何理解增强for循环

package com.lmdedu.enum_;

/**
 * @author TJU第一炼丹师
 * @date 2024-01-18 15:47:12
 * 演示Enum类各种方法使用
 */
public class EnumerationMethod {
    public static void main(String[] args) {
        Season2 autumn = Season2.AUTUMN;
        //输出枚举对象的名称 name
        System.out.println(autumn.name());
        //输出枚举对象的 次序/编号 从0开始编号
        System.out.println(autumn.ordinal());
        //返回一个数组 包含所有定义的枚举对象
        Season2 values[] = Season2.values();
        for (Season2 season: values){//增强for循环
            System.out.println(season.name());
        }

        //关于如何理解增强for循环
        int nums[] = {1,2,9};
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        //上面的就等价于
        for (int i: nums){//每一轮循环都将nums的值取出来给 i
            System.out.println(i);
        }

    }
}

演示Ⅳ：valueOf方法——将指定字符串转换为枚举对象，但要求该指定字符串必须为已有的枚举常量名，否则报异常。

Season类代码不变，Test类代码如下 :

class Test2 {
    public static void main(String[] args) {
        //4.valueOf
        //1）根据你输入的名称 SPRING 到 Season2的枚举对象中去查找，找到返回对象，没找到报错
        Season season_0 = Season.valueOf("SPRING");
        System.out.println("season_0's name = " + season_0);
 
        Season season_00 = Season.SPRING;
        System.out.println("season_00's name = " + season_00);
 
        System.out.println("season_0 和 season_00本质上是同一个对象吗？" + (season_0 == season_00));//true是一个对象
    }
}

演示Ⅴ：compareTo方法——比较两个枚举常量的编号（返回值= 前编号 - 后编号）。如果返回值是0，说明是同一个枚举常量。

Season类代码不变，Test类代码如下 :

class Test2 {
    public static void main(String[] args) {
        //5.compareTo
        Season season_0 = Season.valueOf("SPRING");
        Season season_00 = Season.SPRING;
        System.out.println(season_0.compareTo(season_00));
        System.out.println("==============");
 
        Season season_2 = Season.AUTUMN;
        //season_2.ordinal() - season_0.ordinal()
        System.out.println(season_2.compareTo(season_0));
        System.out.println("==============");
        System.out.println(season_0.compareTo(season_2));
    }
}

六、关于enum实现接口的问题

1.使用enum关键字声明枚举类之后，该枚举类不可以再去继承其他类。这是因为，我们之前通过javap命令反编译枚举类后，可以看到枚举类已经在底层隐式继承了Enum类。而Java是单继承机制，不支持多继承。所以在枚举类后使用extends关键字，IDEA会报错，如下图所示 :

2.enum关键字声明的枚举类虽然不能再去继承其他类了，但是可以去实现接口。

package knowledge.enum_.port;
 
/**
 * @author : Cyan_RA9
 * @version : 2.0
 */
public enum Season implements Climate {
    SPRING,SUMMER,AUTUMN,WINTER,SEASON;    //别忘记这些枚举常量底层是如何实现的!
    @Override
    public void season_circumstance() {
        System.out.println(SPRING + ": warm");
        System.out.println(SUMMER + ": hot");
        System.out.println(AUTUMN + ": cool");
        System.out.println(WINTER + ": cold");
    }
 
    public static void main(String[] args) {
        Season.SEASON.season_circumstance();
    }
}
 
interface Climate {    
    public abstract void season_circumstance();
}

练习

关于为什么会相等，因为BOY其实是public static final的是静态的对象所以共享是同一个对象，被boy和boy2同时指向

package com.lmdedu.enum_;

import java.sql.SQLOutput;

/**
 * @author TJU第一炼丹师
 * @date 2024-01-18 16:50:38
 */
public class EnumerationExercise {
    public static void main(String[] args) {
        Week weeks[] = Week.values();
        System.out.println("所有兴起的信息如下");
        for (Week info: weeks){
            System.out.println(info);
        }
    }
}
enum Week{
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),THURSDAY("星期四")
           ,FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");
    private String info;

    private Week(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }
    //重写toString
    @Override
    public String toString() {
        return info ;
    }
}

TJU@第一炼丹师

关注

22
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Java枚举

枚举全称Enumeration [ˌ ɪnuːməˈ reɪʃn]，简称Enum或者enum。枚举是一组常量的集合。枚举类属于一种特殊的类，里面只包含一组有限的特定的对象。枚举的出现可以解决上述的问题。步骤 :①将自定义类的构造器私有化，使其不能被随随便便地new出对象。②取消类中提供的setXxx方法，仅保留getXxx方法，因为“枚举类”对象仅可读，不能随便修改对于对象的描述。③直接在自定义类中创建一组对象，使用的组合实现底层优化。并且要对外暴露这组对象，因此要添加public修饰符。
复制链接

扫一扫