Enum使用及原理

最新推荐文章于 2024-08-20 18:09:49 发布

joenqc

最新推荐文章于 2024-08-20 18:09:49 发布

阅读量6k

点赞数 3

分类专栏： java 文章标签： enum 枚举

本文链接：https://blog.csdn.net/joenqc/article/details/72588288

版权

java 专栏收录该内容

63 篇文章 0 订阅

订阅专栏

本文详细探讨了Java中枚举类的实现原理及其在实际开发中的应用。包括枚举类如何实现单例模式、枚举类对象的创建过程、枚举类与抽象类Enum的关系、枚举类中静态方法的实现细节，以及如何使用枚举类提高代码可读性和维护性。

摘要由CSDN通过智能技术生成

首先，直接继承抽象类Enum而不选择使用enum关键字创建枚举类是行不通的，通不过编译：

这里写图片描述

枚举类是实现单例的一个不错选择。

枚举类构造函数默认为private。

Enum 一般用来表示一组相同类型的常量。如性别、日期、月份、颜色等。

枚举类对象在枚举类中以public static final 修饰，但自定义枚举类时，可以添加任意访问修饰符的类变量和实例变量。

使用enum声明的枚举类默认为final class 因此不能被继承。

所有enum都继承了java.lang.Enum抽象类，该类的声明为

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

该抽象类中实现的 oridinal、equals、hashCode、clone、compareTo等方法均声明为final，因此自定义的enum不能重写这些方法。

比如对于clone方法，由于每个枚举对象都是singleton，禁止对枚举对象克隆，因此将clone方法声明为final合情合理。

下面来看抽象类Enum的compareTo方法

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

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

getClass()为继承自Object，返回当前对象运行时实际类型对应的Class对象，而getDeclaringClass()为Enum类中的方法，首先获取当前对象的实际class，如果为Enum.class,那么将其返回，如果不是，则返回其超类。
而compareTo方法比较两个对象时，如果两个对象的实际类型和父类型
都不相等，就会抛出类型转换异常。这里比较两个对象的实际类型比较好理解，那为什么要比较对象实际类型的超类型呢？

stackoverflow中给出了答案：

http://stackoverflow.com/questions/5758660/java-enum-getdeclaringclass-vs-getclass

Java enum values are permitted to have value-specific class bodies, e.g. (and I hope this syntax is correct...)

public enum MyEnum {

   A {
       void doSomething() { ... }
   },


   B {
       void doSomethingElse() { ... }
   };

}

This will generate inner classes representing the class bodies for A and B. These inner classes will be subclasses of MyEnum.

MyEnum.A.getClass() will return the anonymous class representing A's class body, which may not be what you want.

MyEnum.A.getDeclaringClass(), on the other hand, will return the Class object representing MyEnum.

For simple enums (i.e. ones without constant-specific class bodies), getClass() and getDeclaringClass() return the same thing.

在我们编写的enum类中，可以声明带body的枚举对象，也就是会生成所谓的匿名类，那么此时该枚举对象的运行时实际类型即为此匿名内部类，而该匿名内部类继承了MyEnum。因此在用compareTo方法比较枚举对象时，不能只靠getClass判断这两个对象类型是否相同。

在java代码中，我们使用 enum 关键字声明一个枚举类，编译器碰到此关键字时，会进行特殊处理，将该名字的枚举类自动extends java.lang.Enum（这也就是枚举类不能显式继承类的原因，单继承），因此该枚举类便自动继承了来自抽象类Enum的那些实例方法。

使用 enum 关键字声明一个枚举类还继承了来自抽象类Enum的静态方法（静态方法可以继承而不能重写，只能隐藏）

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

enumConstantDirectory()为Object类方法

Map<String, T> enumConstantDirectory() {
    if (enumConstantDirectory == null) {
        T[] universe = getEnumConstantsShared();
        if (universe == null)
            throw new IllegalArgumentException(
                getName() + " is not an enum type");
        Map<String, T> m = new HashMap<>(2 * universe.length);
        for (T constant : universe)
            m.put(((Enum<?>)constant).name(), constant);
        enumConstantDirectory = m;
    }
    return enumConstantDirectory;
}

T[] getEnumConstantsShared() {
    if (enumConstants == null) {
        if (!isEnum()) return null;
        try {
            final Method values = getMethod("values");
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                            values.setAccessible(true);
                            return null;
                        }
                    });
            @SuppressWarnings("unchecked")
            T[] temporaryConstants = (T[])values.invoke(null);
            enumConstants = temporaryConstants;
        }
        // These can happen when users concoct enum-like classes
        // that don't comply with the enum spec.
        catch (InvocationTargetException | NoSuchMethodException |
               IllegalAccessException ex) { return null; }
    }
    return enumConstants;
}

从上面代码可以看出，valueOf(Class< T > enumType, String name) 方法获取枚举类对象为懒加载，首先判断enumConstantDirectory 这个map是否为空，如果为空则进行第一次初始化加载枚举类对象，构造枚举类对象的工作是通过反射调用真正的枚举类的values()方法(马上谈到)。

另外，编译器还为新生成的枚举类生成了两个静态方法，重载的valueOf(String name) 和一个values()方法，通过反编译class文件，得到这两个方法的字节码：

这里写图片描述