枚举的本质

最新推荐文章于 2024-11-29 10:17:22 发布

原创最新推荐文章于 2024-11-29 10:17:22 发布 · 1.1k 阅读

2 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

25 篇文章

订阅专栏

本文深入解析枚举类型的概念、使用及实现原理，探讨其在Java中的应用与优势，包括单例特性、枚举实例的创建与访问，以及如何在实际项目中合理运用。

概述

关于枚举类型，我们学过C语言的小伙伴应该都不陌生。所谓枚举类型，是一种特殊的数据结构，它的取值范围是有限的，所有取值结果都可以枚举出来，比如说一年四季（春夏秋冬）。对于确定范围的变量取值，我们通过枚举类型来表现较之用类表示更加简洁、方便、安全。

下边我们借助一些例子来介绍枚举类型的使用以及其实现原理。

基础

枚举类型的定义和使用都是比较简单的，比如要表示一年的四个季节（春夏秋冬）我们可以定下如下类Wether:

public enum Wether{
    SPRING,SUMMER,AUTUMN,WINTER
}

Wether中分别定义了春（SPRING）、夏（SUMMER）、秋（AUTUMN），冬（WINTER）这四个值。枚举类型使用enum这个关键字来进行定义。当然枚举类型可以像类一样单独写到一个文件中，也可以写到一个类内部，仅供该类使用。

使用时也非常简单可以直接通过类型命调用

public class Test {
    public static void main(String[] args) {
        System.out.println("我是春天:"+Wether.SPRING);
        System.out.println("我是夏天:"+Wether.SUMMER);
        System.out.println("我是秋天:"+Wether.AUTUMN);
        System.out.println("我是冬天:"+Wether.WINTER);
    }
}

输出结果如下

原理

看似简单的枚举类Wether其背后有隐藏着什么故事,下边我们拭目以待.

首先我们通过jad来对文件进行反编译我们的到如下代码

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   Wether.java

public final class Wether extends Enum
{

	public static final Wether SPRING;
	public static final Wether SUMMER;
	public static final Wether AUTUMN;
	public static final Wether WINTER;
	private static final Wether $VALUES[];

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

	public static Wether valueOf(String name)
	{
		return (
        )Enum.valueOf(testEnum/Wether, name);
	}

	private Wether(String s, int i)
	{
		super(s, i);
	}

	static 
	{
		SPRING = new Wether("SPRING", 0);
		SUMMER = new Wether("SUMMER", 1);
		AUTUMN = new Wether("AUTUMN", 2);
		WINTER = new Wether("WINTER", 3);
		$VALUES = (new Wether[] {
			SPRING, SUMMER, AUTUMN, WINTER
		});
	}
}

我们会发现java编译器在实现枚举类型的时候,其实是按照类类型来进行处理的,也就是说:枚举类型其本质上仍然是类，是一个继承自Enmu的类。但是由于编译器帮我们默默的做了一些事情，使得我们使用起来更加方便也更加高效。

详细来说针对枚举类型编译器在背后为我们做了一下几件事情。

定义一个继承自Enmu的一个类命名为Wether
为每个枚举实例对应创建一个类对象，这些类对象是用public static final修饰的。同时生成一个数组，用于保存全部的类对象
生成一个静态代码块，用于初始化类对象和类对象数组
生成一个构造函数，构造函数包含自定义参数和两个默认参数（下文会讲解这两个默认参数）
生成一个静态的values()方法，用于返回所有的类对象
生成一个静态的valueOf()方法，根据name参数返回对应的类实例

官方的对编译器对Enum的处理做了如下说明:文档地址

为了便于大家阅读我将我对上边的文档尝试进行了翻译

当让只看官方文档会让人云里雾里的，下边我们结合Enum的源码来进行一些分析。

package java.lang;

import java.io.Serializable;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;


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 ;

    public final int ordinal() {
        return ordinal;
    }

  
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

   
    public String toString() {
        return name;
    }

   
    public final boolean equals(Object other) {
        return this==other;
    }

  
    public final int hashCode() {
        return super.hashCode();
    }

    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    
    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

   
    @SuppressWarnings("unchecked")
    public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
    }

   
    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);
    }

   
    protected final void finalize() { }

    private void readObject(ObjectInputStream in) throws IOException,
        ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }

    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
}

Enum作为java中所有唯一基类，它在一定程度上定义了枚举类型的公共特征，从上边的源码中我们可以看到以下比较重要的几点：

Enum类有两个成员变量，name和ordinal两个成员变量，其中name用于枚举常量的名字，如SPRING,SUMMER,AUTUMN等，oridinal指的是默认编的序号，一般是从0开始。
返回name变量的方法有两个：一个是name()，一个是toString()，它们都是直接返回name变量（也就是说实现是一样的），但是它们所代表的含义确是不同的。

关于两者的区别官方的api说明如下：

从官方api中我们可以看到，name()方法会返回**枚举类型在该枚举类型声明的时所定义的枚举类型的精确名称。**官方不太赞同大多数编程者使用该方法获取枚举名称，而应该使用toString()类型，因为它返回的名称会更加友好。该方法在设计的时候主要是在一些特殊情况下使用（结果的正确性取决于给定的精确名称），而且该方法可能会在发布的过程中发生变化。

给name（）方法类似都是返回枚举常量的名称。官方指出，该方法可被重写（尽管大部分情况下不是必须的，也不建议重写）。当一个对编程者更加友好的字符串名称被发现时，应该重写该方法替代原有的枚举类型名称。

简而言之，给出name方法主要为了便于编程者在某些条件下重写名称的，我们在大部分情况下应该使用toString()。
Enum类不允许克隆，clone()方法直接抛出异常。（保证枚举永远是单例的）
Enum类实现了Comparable接口，因此我们可以直接比较枚举常量的ordinal的值。
Enum类不允许反序列化，为了保证枚举永远是单例的。