Java 枚举类型 enum

zhipingChen

发布于 2018-10-09 14:21:58

1.2K0

发布于 2018-10-09 14:21:58

以下使用 JDK 版本为：1.8.0_121

枚举类型的引入

枚举类型是 Java 5 中增加的一个小特性，在此之前，实现枚举的方式为定义编译期常量形式。而代码中使用编译期常量的方式在理解性和安全性方面存在不足，单纯的常量数值不能够直观的体现出其作为枚举实例的目的，且实际中无限的取值空间也不能很好的与理论上有限的枚举空间相匹配。

常见例证为四季的代码中表示方式

常量形式的表示为：

class Season{
    
    public static final int SPRING = 1;

    public static final int SUMMER = 2;

    public static final int AUTUMN = 3;

    public static final int WINTER = 4;
    
}

enum 枚举类型的表示为：

enum Season{
    SPRING, SUMMER, AUTUMN, WINTER;
}

根据类型的定义可以看出两者存在明显的差异，枚举类型的实例摆脱了数值的限制，能够以实例自身表达其作用和目的。

枚举类型的使用

enum 关键字与常用的 class 关键字作用相似，用于完成对类结构的定义，所以 enum 可以作为一种特殊的类定义方式理解。定义过程与 class 的定义类过程基本相同，同样提供有属性和方法的定义，不同之处在于 enum 定义的类默认继承了 Enum 类，因为 Java 不允许多继承，所以使用 enum 定义的类不能再继承其它类。

使用示例：

enum Season {
    SPRING("first season"), SUMMER("second season"), AUTUMN("third season"), WINTER("last season");

    private String describe;

    Season(String describe) {
        this.describe = describe;
    }

    public String toString() {
        return describe;
    }
}

class Test {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}

输出为：

first season

因为重新定义了 toString 方法，所以打印内容为枚举实例的描述内容。

实例属性 name、ordinal，及同名方法

该示例中给 Season 枚举类型增加了一个 describe 属性，其实在 Enum 类中已经具有两个属性 name 和 ordinal，分别表示枚举实例名称和序号，并提供有同名函数，用于返回实例属性值。

name、ordinal 属性打印示例：

class Test {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
        System.out.println(spring.name());
        System.out.println(spring.ordinal());
    }
}

输出为：

first season
SPRING
0

观察 Enum 源代码中两个属性，及同名函数的定义：

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {

    private final String name;

    public final String name() {
        return name;
    }

    private final int ordinal;

    public final int ordinal() {
        return ordinal;
    }

    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
    ...  // omit some content
}

从源码中可知 Enum 的构造函数为 protected 级别，观察示例中 Season 枚举类内部声明的四个实例，发现并未显式调用基类的构造函数，甚至连自身的构造函数也没有显式调用。由此可知，枚举类内部定义的多个实例，其构造过程是由编译器调用构造函数来处理完成的。

反编译 Season 类定义文件：

final class Season extends Enum
{

    public static Season[] values()
    {
        return (Season[])$VALUES.clone();
    }

    public static Season valueOf(String s)
    {
        return (Season)Enum.valueOf(t1/Season, s);
    }

    private Season(String s, int i, String s1)
    {
        super(s, i);
        describe = s1;
    }

    public String toString()
    {
        return describe;
    }

    public static final Season SPRING;
    public static final Season SUMMER;
    public static final Season AUTUMN;
    public static final Season WINTER;
    private String describe;
    private static final Season $VALUES[];

    static 
    {
        SPRING = new Season("SPRING", 0, "first season");
        SUMMER = new Season("SUMMER", 1, "second season");
        AUTUMN = new Season("AUTUMN", 2, "third season");
        WINTER = new Season("WINTER", 3, "last season");
        $VALUES = (new Season[] {
            SPRING, SUMMER, AUTUMN, WINTER
        });
    }
}

由反编译内容可知，Season 内部声明的多个实例，其构造过程是编译器在静态代码库中，调用 Season 自身和基类的构造函数完成定义的。

valueOf 与 values 函数

从上图中的反编译内容可以发现两个额外的方法定义，其中 valueOf 函数在 Enum 源码中已有定义，但是比较 Enum 源码中的 valueOf 函数与此处反编译生成的 valueOf 函数实现，可以发现，编译器生成的 valueOf 函数内部调用的其实就是 Enum 类中定义的 valueOf 函数。

    // compiler generation
    public static Season valueOf(String s) {
        return (Season)Enum.valueOf(t1 / Season, s);
    }

    // defined in the source code
    public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

上图中第一种为编译器生成的 valueOf 函数体，第二种为 Enum 源码中定义的函数体。观察第二种实现，可以发现，其实调用的是 Class 类中定义的 enumConstantDirectory 函数，在该函数内对参数 enumType 是否为枚举类型进行判断，并返回枚举实例名称和枚举实例构成的 map 对象。

反编译生成的 values 函数，则是返回枚举类内部声明的实例数组的 clone 对象。

valueOf、values 函数示例：

class Test {
    public static void main(String[] args) {
        System.out.println(Arrays.asList(Season.values()));
        System.out.println(Season.valueOf("SUMMER"));
    }
}

输出为：

[first season, second season, third season, last season]
second season

因为重写了 toString 函数，所以输出为 describe 属性构成的数组，根据枚举实例的 name 值，valueOf 函数从 map 集合中返回枚举实例。

compareTo 函数

因为 Enum 类实现了Comparable 接口，而 Comparable 接口中只有一个函数声明，也就是 compareTo 函数，所以枚举实例之间可以进行比较。比较的结果是个整型数字，比较的内容是枚举实例的声明序号，比较的方式是声明序号的差值，即 ordinal 属性的差值。

compareTo 函数示例：

class Test {
    public static void main(String[] args) {
        Season summer = Season.valueOf("SUMMER");
        for(Season s : Season.values()){
            System.out.print(summer.name()+" compare to "+s.name());
            System.out.println(" result: "+summer.compareTo(s));
        }
    }
}

输出为：

SUMMER compare to SPRING result: 1
SUMMER compare to SUMMER result: 0
SUMMER compare to AUTUMN result: -1
SUMMER compare to WINTER result: -2

返回正数表示当前对象较大，0 表示大小相等，负数表示当前对象较小，差值表示声明顺序的差距大小。

枚举类型的 switch 用法

枚举类型描述的是一个有限空间的元素集合，所以对元素的判断应该是常见的操作。枚举类型支持 switch 用法，所以避免了多个 if-else 判断的形式。

switch 使用示例：

class Test {
    public static void main(String[] args) {
        Season summer = Season.valueOf("SUMMER");
        switch (summer){
            case SPRING:
                System.out.println(Season.SPRING);
                break;
            case SUMMER:
                System.out.println(Season.SUMMER);
                break;
            case AUTUMN:
                System.out.println(Season.AUTUMN);
                break;
            case WINTER:
                System.out.println(Season.WINTER);
                break;
            default:
                System.out.println("there is something wrong!");
        }
    }
}

输出为：

second season

枚举类中实现接口函数

枚举类型隐式继承了 Enum 类，所以不能再继承其他类，通过实现接口，可以将实现了同一个接口的多个枚举类型作为同一类，从而实现对枚举类型的划分和归类。由于枚举类型的所有实例都在类内部定义完成，所以枚举类实现接口的方式相较于普通类略有不同。

类内部实现接口函数

enum Season implements Rain{
    SPRING("first season"), SUMMER("second season"), AUTUMN("third season"), WINTER("last season");

    private String describe;

    Season(String describe) {
        this.describe = describe;
    }

    public String toString() {
        return describe;
    }

    public void rain(){  // implement interface method
        System.out.println(this+" is raining.");
    }
}

class Test {
    public static void main(String[] args) {
        Season summer = Season.valueOf("SUMMER");
        for(Season s : Season.values()){
            s.rain();
        }
    }
}

输出为：

first season is raining.
second season is raining.
third season is raining.
last season is raining.

在枚举类内部完成对接口函数的实现，所有枚举类型都调用同样的函数实现。

实例内部实现接口函数

enum Season implements Rain{
    SPRING("first season"){
        public void rain(){  // implement interface method
            System.out.println("first season is raining.");
        }
    }, SUMMER("second season"){
        public void rain(){  // implement interface method
            System.out.println("second season is raining.");
        }
    }, AUTUMN("third season"){
        public void rain(){  // implement interface method
            System.out.println("third season is raining.");
        }
    }, WINTER("last season"){
        public void rain(){  // implement interface method
            System.out.println("last season is raining.");
        }
    };

    private String describe;

    Season(String describe) {
        this.describe = describe;
    }

    public String toString() {
        return describe;
    }
    
}

class Test {
    public static void main(String[] args) {
        Season summer = Season.valueOf("SUMMER");
        for(Season s : Season.values()){
            s.rain();
        }
    }
}

输出为：

first season is raining.
second season is raining.
third season is raining.
last season is raining.

因为枚举类内部声明定义了所有枚举实例，所以当每个实例都实现了接口函数时，在类内部可以不实现接口函数，因为即便类内部实现了，在每个实例的构造时也重写了该接口函数。所以可知，若并没有给每个实例实现该接口函数，则必须在枚举类内部实现该函数。

部分实例内部实现接口函数

enum Season implements Rain {
    SPRING("first season") ,
    SUMMER("second season") {
        public void rain() {  // implement interface method
            System.out.println("heavy rain.");
        }
    }, AUTUMN("third season"), WINTER("last season");

    private String describe;

    Season(String describe) {
        this.describe = describe;
    }

    public String toString() {
        return describe;
    }

    public void rain() {  // implement interface method
        System.out.println("patter raining.");
    }
}

被划分为同一类的枚举类型中，若某个实例在某些细节方面与其他实例较为不同，则可以单独对其进行实现。

引用：

Java Enums Tutorial A Guide to Java Enums

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2018.09.13 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度