欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

夯实Java基础系列14:深入理解Java枚举类

程序员文章站 2022-04-17 22:24:57
本系列文章将整理到我在GitHub上的《Java面试指南》仓库,更多精彩内容请到我的仓库里查看 "https://github.com/h2pl/Java Tutorial" 喜欢的话麻烦点下Star、Fork、Watch三连哈,感谢你的支持。 文章首发于我的个人博客: "www.how2playl ......

本系列文章将整理到我在github上的《java面试指南》仓库,更多精彩内容请到我的仓库里查看

https://github.com/h2pl/java-tutorial

喜欢的话麻烦点下star、fork、watch三连哈,感谢你的支持。

文章首发于我的个人博客:

www.how2playlife.com

本文是微信公众号【java技术江湖】的《夯实java基础系列博文》其中一篇,本文部分内容来源于网络,为了把本文主题讲得清晰透彻,也整合了很多我认为不错的技术博客内容,引用其中了一些比较好的博客文章,如有侵权,请联系作者。

该系列博文会告诉你如何从入门到进阶,一步步地学习java基础知识,并上手进行实战,接着了解每个java知识点背后的实现原理,更完整地了解整个java技术体系,形成自己的知识框架。为了更好地总结和检验你的学习成果,本系列文章也会提供每个知识点对应的面试题以及参考答案。

@[toc] 如果对本系列文章有什么建议,或者是有什么疑问的话,也可以关注公众号【java技术江湖】联系作者,欢迎你参与本系列博文的创作和修订。

枚举(enum)类型是java 5新增的特性,它是一种新的类型,允许用常量来表示特定的数据片断,而且全部都以类型安全的形式来表示。

初探枚举类

在程序设计中,有时会用到由若干个有限数据元素组成的集合,如一周内的星期一到星期日七个数据元素组成的集合,由三种颜色红、黄、绿组成的集合,一个工作班组内十个职工组成的集合等等,程序中某个变量取值仅限于集合中的元素。此时,可将这些数据集合定义为枚举类型。

因此,枚举类型是某类数据可能取值的集合,如一周内星期可能取值的集合为:   { sun,mon,tue,wed,thu,fri,sat}   该集合可定义为描述星期的枚举类型,该枚举类型共有七个元素,因而用枚举类型定义的枚举变量只能取集合中的某一元素值。由于枚举类型是导出数据类型,因此,必须先定义枚举类型,然后再用枚举类型定义枚举型变量。  

enum <枚举类型名> 
  { <枚举元素表> };
  
  其中:关键词enum表示定义的是枚举类型,枚举类型名由标识符组成,而枚举元素表由枚举元素或枚举常量组成。例如: 
  
enum weekdays 
  { sun,mon,tue,wed,thu,fri,sat };
  定义了一个名为 weekdays的枚举类型,它包含七个元素:sun、mon、tue、wed、thu、fri、sat。

在编译器编译程序时,给枚举类型中的每一个元素指定一个整型常量值(也称为序号值)。若枚举类型定义中没有指定元素的整型常量值,则整型常量值从0开始依次递增,因此,weekdays枚举类型的七个元素sun、mon、tue、wed、thu、fri、sat对应的整型常量值分别为0、1、2、3、4、5、6。   注意:在定义枚举类型时,也可指定元素对应的整型常量值。

例如,描述逻辑值集合{true、false}的枚举类型boolean可定义如下:
enum boolean 
  { true=1 ,false=0 };
该定义规定:true的值为1,而false的值为0。
  
而描述颜色集合{red,blue,green,black,white,yellow}的枚举类型colors可定义如下:
enum colors 
  {red=5,blue=1,green,black,white,yellow};
  该定义规定red为5 ,blue为1,其后元素值从2 开始递增加1。green、black、white、yellow的值依次为2、3、4、5。

  此时,整数5将用于表示二种颜色red与yellow。通常两个不同元素取相同的整数值是没有意义的。枚举类型的定义只是定义了一个新的数据类型,只有用枚举类型定义枚举变量才能使用这种数据类型。

枚举类-语法

enum 与 class、interface 具有相同地位; 可以继承多个接口; 可以拥有构造器、成员方法、成员变量; 1.2 枚举类与普通类不同之处

默认继承 java.lang.enum 类,所以不能继承其他父类;其中 java.lang.enum 类实现了 java.lang.serializable 和 java.lang.comparable 接口;

使用 enum 定义,默认使用 final 修饰,因此不能派生子类;

构造器默认使用 private 修饰,且只能使用 private 修饰;

枚举类所有实例必须在第一行给出,默认添加 public static final 修饰,否则无法产生实例;

枚举类的具体使用

这部分内容参考https://blog.csdn.net/qq_27093465/article/details/52180865

常量

public class 常量 {
}
enum color {
    red, green, blue, yellow
}

switch

jdk1.6之前的switch语句只支持int,char,enum类型,使用枚举,能让我们的代码可读性更强。

public static void showcolor(color color) {
        switch (color) {
            case red:
                system.out.println(color);
                break;
            case blue:
                system.out.println(color);
                break;
            case yellow:
                system.out.println(color);
                break;
            case green:
                system.out.println(color);
                break;
        }
    }

向枚举中添加新方法

如果打算自定义自己的方法,那么必须在enum实例序列的最后添加一个分号。而且 java 要求必须先定义 enum 实例。

enum color {
    //每个颜色都是枚举类的一个实例,并且构造方法要和枚举类的格式相符合。
    //如果实例后面有其他内容,实例序列结束时要加分号。
    red("红色", 1), green("绿色", 2), blue("蓝色", 3), yellow("黄色", 4);
    string name;
    int index;
    color(string name, int index) {
        this.name = name;
        this.index = index;
    }
    public void showallcolors() {
        //values是color实例的数组,在通过index和name可以获取对应的值。
        for (color color : color.values()) {
            system.out.println(color.index + ":" + color.name);
        }
    }
}

覆盖枚举的方法

所有枚举类都继承自enum类,所以可以重写该类的方法 下面给出一个tostring()方法覆盖的例子。

@override
public string tostring() {
    return this.index + ":" + this.name;
}

实现接口

所有的枚举都继承自java.lang.enum类。由于java 不支持多继承,所以枚举对象不能再继承其他类。

enum color implements print{
    @override
    public void print() {
        system.out.println(this.name);
    }
}

使用接口组织枚举

搞个实现接口,来组织枚举,简单讲,就是分类吧。如果大量使用枚举的话,这么干,在写代码的时候,就很方便调用啦。

public class 用接口组织枚举 {
    public static void main(string[] args) {
        food cf = chinesefood.dumpling;
        food jf = food.japanesefood.fishpiece;
        for (food food : chinesefood.values()) {
            system.out.println(food);
        }
        for (food food : food.japanesefood.values()) {
            system.out.println(food);
        }
    }
}
interface food {
    enum japanesefood implements food {
        suse, fishpiece
    }
}
enum chinesefood implements food {
    dumpling, tofu
}

枚举类集合

java.util.enumset和java.util.enummap是两个枚举集合。enumset保证集合中的元素不重复;enummap中的 key是enum类型,而value则可以是任意类型。

enumset在jdk中没有找到实现类,这里写一个enummap的例子

public class 枚举类集合 {
    public static void main(string[] args) {
        enummap<color, string> map = new enummap<color, string>(color.class);
        map.put(color.blue, "blue");
        map.put(color.yellow, "yellow");
        map.put(color.red, "red");
        system.out.println(map.get(color.red));
    }
}

使用枚举类的注意事项

夯实Java基础系列14:深入理解Java枚举类

枚举类型对象之间的值比较,是可以使用==,直接来比较值,是否相等的,不是必须使用equals方法的哟。

因为枚举类enum已经重写了equals方法

/**
 * returns true if the specified object is equal to this
 * enum constant.
 *
 * @param other the object to be compared for equality with this object.
 * @return  true if the specified object is equal to this
 *          enum constant.
 */
public final boolean equals(object other) {
    return this==other;
}

枚举类的实现原理

这部分参考https://blog.csdn.net/mhmyqn/article/details/48087247

java从jdk1.5开始支持枚举,也就是说,java一开始是不支持枚举的,就像泛型一样,都是jdk1.5才加入的新特性。通常一个特性如果在一开始没有提供,在语言发展后期才添加,会遇到一个问题,就是向后兼容性的问题。

像java在1.5中引入的很多特性,为了向后兼容,编译器会帮我们写的源代码做很多事情,比如泛型为什么会擦除类型,为什么会生成桥接方法,foreach迭代,自动装箱/拆箱等,这有个术语叫“语法糖”,而编译器的特殊处理叫“解语法糖”。那么像枚举也是在jdk1.5中才引入的,又是怎么实现的呢?

java在1.5中添加了java.lang.enum抽象类,它是所有枚举类型基类。提供了一些基础属性和基础方法。同时,对把枚举用作set和map也提供了支持,即java.util.enumset和java.util.enummap。

接下来定义一个简单的枚举类

public enum day {
    monday {
        @override
        void say() {
            system.out.println("monday");
        }
    }
    , tuesday {
        @override
        void say() {
            system.out.println("tuesday");
        }
    }, friday("work"){
        @override
        void say() {
            system.out.println("friday");
        }
    }, sunday("free"){
        @override
        void say() {
            system.out.println("sunday");
        }
    };
    string work;
    //没有构造参数时,每个实例可以看做常量。
    //使用构造参数时,每个实例都会变得不一样,可以看做不同的类型,所以编译后会生成实例个数对应的class。
    private day(string work) {
        this.work = work;
    }
    private day() {

    }
    //枚举实例必须实现枚举类中的抽象方法
    abstract void say ();

}

反编译结果

d:\mytech\out\production\mytech\com\javase\枚举类>javap day.class
compiled from "day.java"

public abstract class com.javase.枚举类.day extends java.lang.enum<com.javase.枚举类.day> {
  public static final com.javase.枚举类.day monday;
  public static final com.javase.枚举类.day tuesday;
  public static final com.javase.枚举类.day friday;
  public static final com.javase.枚举类.day sunday;
  java.lang.string work;
  public static com.javase.枚举类.day[] values();
  public static com.javase.枚举类.day valueof(java.lang.string);
  abstract void say();
  com.javase.枚举类.day(java.lang.string, int, com.javase.枚举类.day$1);
  com.javase.枚举类.day(java.lang.string, int, java.lang.string, com.javase.枚举类.day$1);
  static {};
}

可以看到,一个枚举在经过编译器编译过后,变成了一个抽象类,它继承了java.lang.enum;而枚举中定义的枚举常量,变成了相应的public static final属性,而且其类型就抽象类的类型,名字就是枚举常量的名字.

同时我们可以在operator.class的相同路径下看到四个内部类的.class文件com/mikan/day$1.class、com/mikan/day$2.class、com/mikan/day$3.class、com/mikan/day$4.class,也就是说这四个命名字段分别使用了内部类来实现的;同时添加了两个方法values()和valueof(string);我们定义的构造方法本来只有一个参数,但却变成了三个参数;同时还生成了一个静态代码块。这些具体的内容接下来仔细看看。

下面分析一下字节码中的各部分,其中:

innerclasses:
     static #23; //class com/javase/枚举类/day$4
     static #18; //class com/javase/枚举类/day$3
     static #14; //class com/javase/枚举类/day$2
     static #10; //class com/javase/枚举类/day$1

从中可以看到它有4个内部类,这四个内部类的详细信息后面会分析。

static {};
    descriptor: ()v
    flags: acc_static
    code:
      stack=5, locals=0, args_size=0
         0: new           #10                 // class com/javase/枚举类/day$1
         3: dup
         4: ldc           #11                 // string monday
         6: iconst_0
         7: invokespecial #12                 // method com/javase/枚举类/day$1."<init>":(ljava/lang/string;i)v
        10: putstatic     #13                 // field monday:lcom/javase/枚举类/day;
        13: new           #14                 // class com/javase/枚举类/day$2
        16: dup
        17: ldc           #15                 // string tuesday
        19: iconst_1
        20: invokespecial #16                 // method com/javase/枚举类/day$2."<init>":(ljava/lang/string;i)v
        //后面类似,这里省略
}

其实编译器生成的这个静态代码块做了如下工作:分别设置生成的四个公共静态常量字段的值,同时编译器还生成了一个静态字段$values,保存的是枚举类型定义的所有枚举常量 编译器添加的values方法:

public static com.javase.day[] values();  
  flags: acc_public, acc_static  
  code:  
    stack=1, locals=0, args_size=0  
       0: getstatic     #2                  // field $values:[lcom/javase/day;  
       3: invokevirtual #3                  // method "[lcom/mikan/day;".clone:()ljava/lang/object;  
       6: checkcast     #4                  // class "[lcom/javase/day;"  
       9: areturn  
这个方法是一个公共的静态方法,所以我们可以直接调用该方法(day.values()),返回这个枚举值的数组,另外,这个方法的实现是,克隆在静态代码块中初始化的$values字段的值,并把类型强转成day[]类型返回。

造方法为什么增加了两个参数?

有一个问题,构造方法我们明明只定义了一个参数,为什么生成的构造方法是三个参数呢?

从enum类中我们可以看到,为每个枚举都定义了两个属性,name和ordinal,name表示我们定义的枚举常量的名称,如friday、tuesday,而ordinal是一个顺序号,根据定义的顺序分别赋予一个整形值,从0开始。在枚举常量初始化时,会自动为初始化这两个字段,设置相应的值,所以才在构造方法中添加了两个参数。即:

另外三个枚举常量生成的内部类基本上差不多,这里就不重复说明了。

我们可以从enum类的代码中看到,定义的name和ordinal属性都是final的,而且大部分方法也都是final的,特别是clone、readobject、writeobject这三个方法,这三个方法和枚举通过静态代码块来进行初始化一起。

它保证了枚举类型的不可变性,不能通过克隆,不能通过序列化和反序列化来复制枚举,这能保证一个枚举常量只是一个实例,即是单例的,所以在effective java中推荐使用枚举来实现单例。

枚举类实战

实战一无参

(1)定义一个无参枚举类

enum seasontype {
    spring, summer, autumn, winter
}

(2)实战中的使用

// 根据实际情况选择下面的用法即可
seasontype springtype = seasontype.spring;    // 输出 spring 
string springstring = seasontype.spring.tostring();    // 输出 spring

实战二有一参

(1)定义只有一个参数的枚举类

enum seasontype {
    // 通过构造函数传递参数并创建实例
    spring("spring"),
    summer("summer"),
    autumn("autumn"),
    winter("winter");

    // 定义实例对应的参数
    private string msg;

    // 必写:通过此构造器给枚举值创建实例
    seasontype(string msg) {
        this.msg = msg;
    }

    // 通过此方法可以获取到对应实例的参数值
    public string getmsg() {
        return msg;
    }
}

(2)实战中的使用

// 当我们为某个实例类赋值的时候可使用如下方式
string msg = seasontype.spring.getmsg();    // 输出 spring

实战三有两参

(1)定义有两个参数的枚举类

public enum season {
    // 通过构造函数传递参数并创建实例
    spring(1, "spring"),
    summer(2, "summer"),
    autumn(3, "autumn"),
    winter(4, "winter");

    // 定义实例对应的参数
    private integer key;
    private string msg;

    // 必写:通过此构造器给枚举值创建实例
    season(integer key, string msg) {
        this.key = key;
        this.msg = msg;
    }

    // 很多情况,我们可能从前端拿到的值是枚举类的 key ,然后就可以通过以下静态方法获取到对应枚举值
    public static season valueofkey(integer key) {
        for (season season : season.values()) {
            if (season.key.equals(key)) {
                return season;
            }
        }
        throw new illegalargumentexception("no element matches " + key);
    }

    // 通过此方法可以获取到对应实例的 key 值
    public integer getkey() {
        return key;
    }

    // 通过此方法可以获取到对应实例的 msg 值
    public string getmsg() {
        return msg;
    }
}

(2)实战中的使用

// 输出 key 为 1 的枚举值实例
season season = season.valueofkey(1);
// 输出 spring 实例对应的 key
integer key = season.spring.getkey();
// 输出 spring 实例对应的 msg
string msg = season.spring.getmsg();

枚举类总结

其实枚举类懂了其概念后,枚举就变得相当简单了,随手就可以写一个枚举类出来。所以如上几个实战小例子一定要先搞清楚概念,然后在练习几遍就 ok 了。

重要的概念,我在这里在赘述一遍,帮助老铁们快速掌握这块知识,首先记住,枚举类中的枚举值可以没有参数,也可以有多个参数,每一个枚举值都是一个实例;

并且还有一点很重要,就是如果枚举值有 n 个参数,那么构造函数中的参数值肯定有 n 个,因为声明的每一个枚举值都会调用构造函数去创建实例,所以参数一定是一一对应的;既然明白了这一点,那么我们只需要在枚举类中把这 n 个参数定义为 n 个成员变量,然后提供对应的 get() 方法,之后通过实例就可以随意的获取实例中的任意参数值了。

如果想让枚举类更加的好用,就可以模仿我在实战三中的写法那样,通过某一个参数值,比如 key 参数值,就能获取到其对应的枚举值,然后想要什么值,就 get 什么值就好了。

枚举 api

我们使用 enum 定义的枚举类都是继承 java.lang.enum 类的,那么就会继承其 api ,常用的 api 如下:

  • string name()

获取枚举名称

  • int ordinal()

获取枚举的位置(下标,初始值为 0 )

  • valueof(string msg)

通过 msg 获取其对应的枚举类型。(比如实战二中的枚举类或其它枚举类都行,只要使用得当都可以使用此方法)

  • values()

获取枚举类中的所有枚举值(比如在实战三中就使用到了)

总结

枚举本质上是通过普通的类来实现的,只是编译器为我们进行了处理。每个枚举类型都继承自java.lang.enum,并自动添加了values和valueof方法。

而每个枚举常量是一个静态常量字段,使用内部类实现,该内部类继承了枚举类。所有枚举常量都通过静态代码块来进行初始化,即在类加载期间就初始化

另外通过把clone、readobject、writeobject这三个方法定义为final的,同时实现是抛出相应的异常。这样保证了每个枚举类型及枚举常量都是不可变的。可以利用枚举的这两个特性来实现线程安全的单例。

参考文章

微信公众号

java技术江湖

如果大家想要实时关注我更新的文章以及分享的干货的话,可以关注我的公众号【java技术江湖】一位阿里 java 工程师的技术小站,作者黄小斜,专注 java 相关技术:ssm、springboot、mysql、分布式、中间件、集群、linux、网络、多线程,偶尔讲点docker、elk,同时也分享技术干货和学习经验,致力于java全栈开发!

java工程师必备学习资源: 一些java工程师常用学习资源,关注公众号后,后台回复关键字 “java” 即可免费无套路获取。

夯实Java基础系列14:深入理解Java枚举类

个人公众号:黄小斜

作者是 985 硕士,蚂蚁金服 java 工程师,专注于 java 后端技术栈:springboot、mysql、分布式、中间件、微服务,同时也懂点投资理财,偶尔讲点算法和计算机理论基础,坚持学习和写作,相信终身学习的力量!

程序员3t技术学习资源: 一些程序员学习技术的资源大礼包,关注公众号后,后台回复关键字 “资料” 即可免费无套路获取。

夯实Java基础系列14:深入理解Java枚举类