java 枚举(enum) 全面解读开发者社区

java 枚举(enum) 全面解读

// 定义
public enum Color {
    BLACK, WHITE
// 使用
public class Main {
    public static void main(String[] args) {
        System.out.println(Color.BLACK);
// 结果
// BLACK

// final修饰,无法被继承
public final class Color extends Enum {
    // 为了避免 返回的数组修改,而引起内部values值的改变,返回的是原数组的副本
    public static Color[] values() {
        return (Color[]) $VALUES.clone();
    // 按名字获取枚举实例
    public static Color valueOf(String name) {
        return (Color) Enum.valueOf(em / Color, name);
    // 私有的构造函数
    private Color(String name, int ordinal) {
        super(name, ordinal);
    // enum第一行的声明的变量,都对应一个枚举实例对象
    public static final Color BLACK;
    public static final Color WHITE;
    private static final Color $VALUES[];
    // 静态域初始化,说明在类加载的cinit阶段就会被实例化,jvm能够保证类加载过程的线程安全
    static {
        BLACK = new Color("BLACK", 0);
        WHITE = new Color("WHITE", 1);
        $VALUES = (new Color[]{
                BLACK, WHITE
}

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

/**
     * Returns the ordinal of this enumeration constant (its position
     * in its enum declaration, where the initial constant is assigned
     * an ordinal of zero).
     * Most programmers will have no use for this method.  It is
     * designed for use by sophisticated enum-based data structures, such
     * as {@link java.util.EnumSet} and {@link java.util.EnumMap}.
     * @return the ordinal of this enumeration constant
    public final int ordinal() {
        return ordinal;
    }

/**
     * Returns the name of this enum constant, as contained in the
     * declaration.  This method may be overridden, though it typically
     * isn't necessary or desirable.  An enum type should override this
     * method when a more "programmer-friendly" string form exists.
     * @return the name of this enum constant
    public String toString() {
        return name;
    }

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

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

    // 私有的构造函数
    private Color(String name, int ordinal) {
        super(name, ordinal);
    }

    /**
     * Throws CloneNotSupportedException.  This guarantees that enums
     * are never cloned, which is necessary to preserve their "singleton"
     * status.
    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    static void reflectTest() throws Exception {
        // 获取类对象
        Class<?> cls = Class.forName("em.Color");
        // 获取 color 的构造函数
        Constructor<?> constructor = cls.getDeclaredConstructor(String.class, int.class);
        // 获取访问权限
        constructor.setAccessible(true);
        // 实例化
        Object reflectColor = constructor.newInstance("name", 0);
    // 报错
    Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at Main.reflect(Main.java:24)
    at Main.main(Main.java:13)

    void enmuTest() {
        Color tag = Color.BLACK;
        switch (tag) {
            case WHITE:
                break;
            case BLACK:
                break;
    }

// 实现Runnable接口,在这个类中没有意义,只是为了举例
public enum Color implements Runnable {
    WHITE("黑色"),
    BLACK("白色");
    private final String value;
    // 自定义构造,虽然没有写private,但是默认就是private
    Color(String v) {
        value = v;
    // 自定义方法
    public void draw() {
        System.out.println("绘制 " + value);
    // 重写方法
    @Override
    public String toString() {
        return value;
    // 实现接口方法
    @Override
    public void run() {
        // todo ...
}

public enum Singleton {
    INSTANCE;
    public void method() {
        // todo ...
}

public enum Operation {
    PLUS {
        // 实例中实现抽象方法
        public double apply(double x, double y) {
            return x + y;
    MINUS {
        public double apply(double x, double y) {
            return x - y;
    // 声明抽象方法
    public abstract double apply(double x, double y);
 double result = Operation.PLUS.apply(1, 2);

java 枚举(enum) 全面解读

java 枚举(enum) 全面解读

简介

原理分析

Enum成员变量和方法分析

每一个枚举类型极其定义的枚举变量在JVM中都是唯一的

枚举类的特点总结

枚举的使用

枚举与单例模式

枚举与策略模式

枚举与Android