专栏首页老马说编程(23) 枚举的本质 / 计算机程序的思维逻辑

(23) 枚举的本质 / 计算机程序的思维逻辑

前面系列,我们介绍了Java中表示和操作数据的基本数据类型、类和接口,本节探讨Java中的枚举类型。

所谓枚举,是一种特殊的数据,它的取值是有限的,可以枚举出来的,比如说一年就是有四季、一周有七天,虽然使用类也可以处理这种数据,但枚举类型更为简洁、安全和方便。

下面我们就来介绍枚举的使用,同时介绍其实现原理。

基础

基本用法

定义和使用基本的枚举是比较简单的,我们来看个例子,为表示衣服的尺寸,我们定义一个枚举类型Size,包括三个尺寸,小/中/大,代码如下:

public enum Size {
    SMALL, MEDIUM, LARGE
}

枚举使用enum这个关键字来定义,Size包括三个值,分别表示小、中、大,值一般是大写的字母,多个值之间以逗号分隔。枚举类型可以定义为一个单独的文件,也可以定义在其他类内部。

可以这样使用Size:

Size size = Size.MEDIUM

Size size声明了一个变量size,它的类型是Size,size=Size.MEDIUM将枚举值MEDIUM赋值给size变量。

枚举变量的toString方法返回其字面值,所有枚举类型也都有一个name()方法,返回值与toString()一样,例如:

Size size = Size.SMALL;
System.out.println(size.toString());

System.out.println(size.name());

输出都是SMALL。

枚举变量可以使用equals和==进行比较,结果是一样的,例如:

Size size = Size.SMALL;
System.out.println(size==Size.SMALL);
System.out.println(size.equals(Size.SMALL));
System.out.println(size==Size.MEDIUM);

上面代码的输出结果为三行,分别是true, true, false。

枚举值是有顺序的,可以比较大小。枚举类型都有一个方法int ordinal(),表示枚举值在声明时的顺序,从0开始,例如,如下代码输出为1:

Size size = Size.MEDIUM;
System.out.println(size.ordinal());

另外,枚举类型都实现了Java API中的Comparable接口,都可以通过方法compareTo与其他枚举值进行比较,比较其实就是比较ordinal的大小,例如,如下代码输出为-1,表示SMALL小于MEDIUM:

Size size = Size.SMALL;
System.out.println(size.compareTo(Size.MEDIUM));

枚举变量可以用于和其他类型变量一样的地方,如方法参数、类变量、实例变量等,枚举还可以用于switch语句,代码如下所示:

static void onChosen(Size size){
    switch(size){
    case SMALL:
        System.out.println("chosen small"); break;
    case MEDIUM:
        System.out.println("chosen medium"); break;
    case LARGE:
        System.out.println("chosen large"); break;
    }
}

在switch语句内部,枚举值不能带枚举类型前缀,例如,直接使用SMALL,不能使用Size.SMALL。

枚举类型都有一个静态的valueOf(String)方法,可以返回字符串对应的枚举值,例如,以下代码输出为true:

System.out.println(Size.SMALL==Size.valueOf("SMALL"));

枚举类型也都有一个静态的values方法,返回一个包括所有枚举值的数组,顺序与声明时的顺序一致,例如:

for(Size size : Size.values()){
    System.out.println(size);
}

屏幕输出为三行,分别是SMALL, MEDIUM, LARGE。

枚举的好处

Java是从JDK 5才开始支持枚举的,在此之前,一般是在类中定义静态整形变量来实现类似功能,代码如下所示:

class Size {
    public static final int SMALL = 0;
    public static final int MEDIUM = 1;
    public static final int LARGE = 2;
}

枚举的好处是比较明显的:

  • 定义枚举的语法更为简洁。
  • 枚举更为安全,一个枚举类型的变量,它的值要么为null,要么为枚举值之一,不可能为其他值,但使用整形变量,它的值就没有办法强制,值可能就是无效的。
  • 枚举类型自带很多便利方法(如values, valueOf, toString等),易于使用。

基本实现原理

枚举类型实际上会被Java编译器转换为一个对应的类,这个类继承了Java API中的java.lang.Enum类。

Enum类有两个实例变量name和ordinal,在构造方法中需要传递,name(), toString(), ordinal(), compareTo(), equals()方法都是由Enum类根据其实例变量name和ordinal实现的。

values和valueOf方法是编译器给每个枚举类型自动添加的,上面的枚举类型Size转换后的普通类的代码大概如下所示:

public final class Size extends Enum<Size> {
    public static final Size SMALL = new Size("SMALL",0);
    public static final Size MEDIUM = new Size("MEDIUM",1);
    public static final Size LARGE = new Size("LARGE",2);
 
    private static Size[] VALUES = 
            new Size[]{SMALL,MEDIUM,LARGE};
 
    private Size(String name, int ordinal){
        super(name, ordinal);
    }
 
    public static Size[] values(){
        Size[] values = new Size[VALUES.length];
        System.arraycopy(VALUES, 0, 
                values, 0, VALUES.length);
        return values;
    }
 
    public static Size valueOf(String name){
        return Enum.valueOf(Size.class, name);
    }
}

解释几点:

  • Size是final的,不能被继承,Enum<Size>表示父类,<Size>是泛型写法,我们后续文章介绍,此处可以忽略。
  • Size有一个私有的构造方法,接受name和ordinal,传递给父类,私有表示不能在外部创建新的实例。
  • 三个枚举值实际上是三个静态变量,也是final的,不能被修改。
  • values方法是编译器添加的,内部有一个values数组保持所有枚举值。
  • valueOf方法调用的是父类的方法,额外传递了参数Size.class,表示类的类型信息,类型信息我们后续文章介绍,父类实际上是回过头来调用values方法,根据name对比得到对应的枚举值的。

一般枚举变量会被转换为对应的类变量,在switch语句中,枚举值会被转换为其对应的ordinal值。

可以看出,枚举类型本质上也是类,但由于编译器自动做了很多事情,它的使用也就更为简洁、安全和方便。

典型场景

用法

以上枚举用法是最简单的,实际中枚举经常会有关联的实例变量和方法,比如说,上面的Size例子,每个枚举值可能有关联的缩写和中文名称,可能需要静态方法根据缩写返回对应的枚举值,修改后的Size代码如下所示:

public enum Size {
    SMALL("S","小号"), 
    MEDIUM("M","中号"), 
    LARGE("L","大号");
 
    private String abbr;
    private String title;
 
    private Size(String abbr, String title){
        this.abbr = abbr;
        this.title = title;
    }

    public String getAbbr() {
        return abbr;
    }

    public String getTitle() {
        return title;
    }
 
    public static Size fromAbbr(String abbr){
        for(Size size : Size.values()){
            if(size.getAbbr().equals(abbr)){
                return size;
            }
        }
        return null;
    }
}

以上代码定义了两个实例变量abbr和title,以及对应的get方法,分别表示缩写和中文名称,定义了一个私有构造方法,接受缩写和中文名称,每个枚举值在定义的时候都传递了对应的值,同时定义了一个静态方法fromAbbr根据缩写返回对应的枚举值。

需要说明的是,枚举值的定义需要放在最上面,枚举值写完之后,要以分号(;)结尾,然后才能写其他代码。

这个枚举定义的使用与其他类类似,比如说:

Size s = Size.MEDIUM;
System.out.println(s.getAbbr());

s = Size.fromAbbr("L");
System.out.println(s.getTitle());

以上代码分别输出: M, 大号

实现原理

加了实例变量和方法后,枚举转换后的类与上面的类似,只是增加了对应的变量和方法,修改了构造方法,代码不同之处大概如下所示:

public final class Size extends Enum<Size> {
  public static final Size SMALL =        
          new Size("SMALL",0, "S", "小号");     
  public static final Size MEDIUM =       
          new Size("MEDIUM",1,"M","中号");      
  public static final Size LARGE =        
          new Size("LARGE",2,"L","大号");       
 
  private String abbr;                    
  private String title;                   
 
  private Size(String name, int ordinal,  
          String abbr, String title){         
      super(name, ordinal);               
      this.abbr = abbr;                   
      this.title = title;                 
  }
  //... 其他代码
}  

说明

每个枚举值经常有一个关联的标示(id),通常用int整数表示,使用整数可以节约存储空间,减少网络传输。一个自然的想法是使用枚举中自带的ordinal值,但ordinal并不是一个好的选择。

为什么呢?因为ordinal的值会随着枚举值在定义中的位置变化而变化,但一般来说,我们希望id值和枚举值的关系保持不变,尤其是表示枚举值的id已经保存在了很多地方的时候。

比如说,上面的Size例子,Size.SMALL的ordinal的值为0,我们希望0表示的就是Size.SMALL的,但如果我们增加一个表示超小的值XSMALL呢?

public enum Size {
    XSMALL, SMALL, MEDIUM, LARGE
}

这时,0就表示XSMALL了。

所以,一般是增加一个实例变量表示id,使用实例变量的另一个好处是,id可以自己定义。比如说,Size例子可以写为:

public enum Size {
    XSMALL(10), SMALL(20), MEDIUM(30), LARGE(40);
 
    private int id;
    private Size(int id){
        this.id = id;
    }
    public int getId() {
        return id;
    }
}

高级用法

枚举还有一些高级用法,比如说,每个枚举值可以有关联的类定义体,枚举类型可以声明抽象方法,每个枚举值中可以实现该方法,也可以重写枚举类型的其他方法。

比如说,我们看改后的Size代码(这个代码实际意义不大,主要展示语法):

public enum Size {
    SMALL {
        @Override
        public void onChosen() {
            System.out.println("chosen small");
        }
    },MEDIUM {
        @Override
        public void onChosen() {
            System.out.println("chosen medium");
        }
    },LARGE {
        @Override
        public void onChosen() {
            System.out.println("chosen large"); 
        }
    };
 
    public abstract void onChosen();
}

Size枚举类型定义了onChosen抽象方法,表示选择了该尺寸后执行的代码,每个枚举值后面都有一个类定义体{},都重写了onChosen方法。

这种写法有什么好处呢?如果每个或部分枚举值有一些特定的行为,使用这种写法比较简洁。对于这个例子,上面我们介绍了其对应的switch语句,在switch语句中根据size的值执行不同的代码。

switch的缺陷是,定义swich的代码和定义枚举类型的代码可能不在一起,如果新增了枚举值,应该需要同样修改switch代码,但可能会忘记,而如果使用抽象方法,则不可能忘记,在定义枚举值的同时,编译器会强迫同时定义相关行为代码。所以,如果行为代码和枚举值是密切相关的,使用以上写法可以更为简洁、安全、容易维护。

这种写法内部是怎么实现的呢?每个枚举值都会生成一个类,这个类继承了枚举类型对应的类,然后再加上值特定的类定义体代码,枚举值会变成这个子类的对象,具体代码我们就不赘述了。

枚举还有一些其他高级用法,比如说,枚举可以实现接口,也可以在接口中定义枚举,使用相对较少,本文就不介绍了。

小结

本节介绍了枚举类型,介绍了基础用法、典型场景及高级用法,不仅介绍了如何使用,还介绍了实现原理,对于枚举类型的数据,虽然直接使用类也可以处理,但枚举类型更为简洁、安全和方便。

我们之前提到过异常,但并未深入讨论,让我们下节来探讨。

本文分享自微信公众号 - 老马说编程(laoma_shuo),作者:老马

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2016-06-30

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • (50) 剖析EnumMap / 计算机程序的思维逻辑

    查看历史文章,请点击上方链接关注公众号。 上节我们提到,如果需要一个Map的实现类,并且键的类型为枚举类型,可以使用HashMap,但应该使用一个专门的实现类E...

    swiftma
  • (18) 为什么说继承是把双刃剑 / 计算机程序的思维逻辑

    继承是把双刃剑 通过前面几节,我们应该对继承有了一个比较好的理解,但之前我们说继承其实是把双刃剑,为什么这么说呢?一方面是因为继承是非常强大的,另一方面是因为...

    swiftma
  • (72) 显式条件 / 计算机程序的思维逻辑

    上节我们介绍了显式锁,本节介绍关联的显式条件,介绍其用法和原理。显式条件也可以被称做条件变量、条件队列、或条件,后文我们可能会交替使用。 用法 基本概念和方法...

    swiftma
  • Java 枚举查找并不抛异常的实现

    Java Enum是一个非常有用的功能,但很多人通常并不能充分利用,这是因为一些库不会优先择用该功能。通常我们也可以正确使用Java枚举功能,但在许多代码库中往...

    哲洛不闹
  • ElasticSearch 5.4.1 PutMapppingRequestBuilder的setSource方法过时

    过时的方法: 此方法是在创建es索引,type后然后进行document字段定义时候使用

    MickyInvQ
  • 深度学习|循环神经网络之LSTM(后篇)

    01 — 回顾 昨天推送了循环神经网络LSTM的前半部分,说到构成其网络模型:输入层包含一系列时序:x0, x1, ..., xt,隐含层是实现 Long-te...

    double
  • mysql的一些常用操作(一)

    2.进入mysql环境中,由于自己没有设置密码,直接回车进入即可(要将bin加入到环境变量path中)

    绝命生
  • 亲耳“听见”神经网络的声音:梯度变化一听即可辨别(附代码)

    网友做了一个非常有趣的实验:将每个神经网络层梯度范式转换成了一个音调,这样人类就可以凭借听觉,来很好的分辨出非常小的干扰,比如节奏和音调。

    代码医生工作室
  • 亲耳“听见”神经网络的声音:梯度变化一听即可辨别(附代码)

    网友做了一个非常有趣的实验:将每个神经网络层梯度范式转换成了一个音调,这样人类就可以凭借听觉,来很好的分辨出非常小的干扰,比如节奏和音调。

    新智元
  • 49.python str/bytes/unicode区别详解

    在讲解 str / bytes /unicode区别之前首先要明白字节和字符的区别,请参考:bytearray/bytes/string区别 中对字节和字符有清...

    猿说编程[Python和C]

扫码关注云+社区

领取腾讯云代金券