从源码角度看枚举

目录

• 概述
• 基础
• 原理
• 使用场景

概述

关于枚举类型，我们学过 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 中所有唯一基类，它在一定程度上定义了枚举类型的公共特征，从上边的源码中我们可以看到以下比较重要的几点：

1. Enum 类有两个成员变量，name 和 ordinal 两个成员变量，其中 name 用于枚举常量的名字，如 SPRING,SUMMER,AUTUMN 等，oridinal 指的是默认编的序号，一般是从 0 开始。

2. 返回 name 变量的方法有两个：一个是 name()，一个是 toString()，它们都是直接返回 name 变量（也就是说实现是一样的），但是它们所代表的含义确是不同的。

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

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

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

   简而言之，给出 name 方法主要为了便于编程者在某些条件下重写名称的，我们在大部分情况下应该使用 toString()。

3. Enum 类不允许克隆，clone() 方法直接抛出异常。（保证枚举永远是单例的）

4. Enum 类实现了 Comparable 接口，因此我们可以直接比较枚举常量的 ordinal 的值。

5. Enum 类不允许反序列化，为了保证枚举永远是单例的。

使用场景

学为所用，讲了那么多主要还是为了能用好枚举，因此我简单总结了一个枚举类型常用的一些场景：

1. 当变量是有穷对象的集合时我们可以尝试使用枚举类型，比如使用到季节(Wether)的时候。
2. 在某些场景下，需要变量是单例的（单例设计模式），我们也可以考虑使用枚举类型，因为枚举类型是天生单例的。