我看JAVA 之 枚举类型-阿里云开发者社区

开发者社区> 开发与运维> 正文

我看JAVA 之 枚举类型

简介: 我看JAVA 之 枚举类型 注:基于jdk11 Enum Enum是Java(1.5+)中所有枚举类型的公共基类。有关枚举的更多信息,包括编译器合成的隐式声明方法的描述,可以在Java™语言规范的第8.9节中找到。

我看JAVA 之 枚举类型

注:基于jdk11

Enum

Enum是Java(1.5+)中所有枚举类型的公共基类。有关枚举的更多信息,包括编译器合成的隐式声明方法的描述,可以在Java™语言规范的
[第8.9节](https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.9)中找到。
当使用枚举类型作为Set中的元素或Map中的key时,可以使用专用且高效的java.util.EnumSetjava.util.EnumMap实现。

定义一个枚举类,隐式继承了java.lang.Enum类(所以枚举类只能去实现接口不能显式继承其他类),见如下代码块:
enum Color {//
   RED, GREEN, BLANK, YELLOW
}

实现了如下几个接口

1. Comparable
2. Serializable

源码分析:

public abstract class Enum<E extends Enum<E>>
    implements Comparable<E>, Serializable {
/**
 * accessing this field.枚举常量名称,访问名称时,最好使用toString()方法而不是直接访问name字段。
 */
private final String name;

/**
 * 枚举常量名称,访问名称时,最好使用toString()方法而不是此方法。
 */
public final String name() {
    return name;
}

/**
 * 枚举常量在枚举类中定义的次序,次序从0开始。开发人员很少用到这个字段。此字典被设计用来在基于枚举类型的复杂数据结构中,如 java.util.EnumSet 和 java.util.EnumMap。
 *
 */
private final int ordinal;

public final int ordinal() {
    return ordinal;
}

/**
 * Sole constructor.  Programmers cannot invoke this constructor.
 * It is for use by code emitted by the compiler in response to
 * enum type declarations.
 * 唯一的构造器。开发人员不能调用这个构造函数。它由编译器调用以响应枚举类型的声明。
 */
protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

/**
 * 默认返回枚举常量的名字,此方法可以被覆盖以便返回更加友好name。
 *
 * @return the name of this enum constant
 */
public String toString() {
    return name;
}

/**
 * Returns true if the specified object is equal to this
 * enum constant.
 *
 * @param other the object to be compared for equality with this object.
 * @return  true if the specified object is equal to this
 *          enum constant.
 */
public final boolean equals(Object other) {
    return this==other;
}

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

/**
 * 枚举类型不可以克隆,以保持其单例性。
 * @return (never returns)
 */
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;
}

/**
 * 返回枚举常量对应的类对象。如果两个枚举常量调用getDeclaringClass()值相等,name这两个枚举对象的枚举类型相同。
 */
@SuppressWarnings("unchecked")
public final Class<E> getDeclaringClass() {
    Class<?> clazz = getClass();
    Class<?> zuper = clazz.getSuperclass();
    return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
}

/**
 * 返回指定枚举类型和名称的枚举常量。参数name一定要与指定枚举类型的常量名称相同(多余的空白字符也是不被允许的)。
 */
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);
}

/**
 * 枚举类没有 finalize()
 */
@SuppressWarnings("deprecation")
protected final void finalize() { }

/**
 * prevent default deserialization
 */
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");
}
}

适用原则

枚举在什么地方适用呢?一条普遍规则是,任何使用常量的地方,例如目前用 switch 代码切换常量的地方。如果只有单独一个值(例如,鞋的最大尺寸,或者笼子中能装猴子的最大数目),则还是把这个任务留给常量吧。但是,如果定义了一组值,而这些值中的任何一个都可以用于特定的数据类型,那么将枚举用在这个地方最适合不过。

例子:

    package chapter03;

    public class TestEnum {
        public static void main(String [] args) {
            System.out.println(Color.RED);
            System.out.println(Color.RED.name());
            System.out.println(Color.RED.ordinal());
            System.out.println(Color.class);
            System.out.println(Color.class.isEnum());

            System.out.println(Color.RED.getDeclaringClass());

            System.out.println("--- Class.getEnumConstants() ---");
            for (Color color: Color.RED.getClass().getEnumConstants()) {
                System.out.println(color);
            }

            System.out.println("--- interface enhance ---");
            System.out.println(Color.RED.info());

            System.out.println("--- switch clause ---");
            System.out.println(swithColor(Color.RED));

            System.out.println("--- Enum.valueOf() ---");
            System.out.println(Enum.valueOf(Color.class, "YELLOW"));
            System.out.println(Enum.valueOf(Color.class, " YELLOW"));
        }

        public static Color swithColor(Color color) {
            switch (color) {
                case RED : return Color.GREEN;
                case GREEN : return Color.YELLOW;
                case YELLOW : return Color.RED;
                default: return Color.GREEN;
            }

        }
    }
    interface ColorInterface {
        String info();
    }
    enum Color implements ColorInterface{
       RED, GREEN, YELLOW;

        @Override
        public String info() {
            return name() + "'s info";
        }
    }

打印结果如下:

    RED
    RED
    0
    class chapter03.Color
    true
    class chapter03.Color
    --- Class.getEnumConstants() ---
    RED
    GREEN
    YELLOW
    --- interface enhance ---
    RED's info
    --- switch clause ---
    GREEN
    --- Enum.valueOf() ---
    YELLOW
    Exception in thread "main" java.lang.IllegalArgumentException: No enum constant chapter03.Color. 
        at java.base/java.lang.Enum.valueOf(Enum.java:240)
        at chapter03.TestEnum.main(TestEnum.java:21)

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章