java枚举类型的实现原理

转自
https://blog.csdn.net/mhmyqn/article/details/48087247

Java在1.5中添加了java.lang.Enum抽象类，它是所有枚举类型基类。提供了一些基础属性和基础方法。同时，对把枚举用作Set和Map也提供了支持，即java.util.EnumSet和java.util.EnumMap。

如何定义枚举类型

比如表示加减乘除操作，我们可以定义如下枚举：

package com.mikan;
 
/**
 * @author Mikan
 * @date 2015-08-29 12:06
 */
public enum Operator {
 
    ADD,
    SUBTRACT,
    MULTIPLY,
    DIVIDE
 
}

上面的枚举定义了四个枚举常量，同时，在枚举中还可以定义普通方法、抽象方法，如下所示：

package com.mikan;
 
/**
 * @author Mikan
 * @date 2015-08-29 12:06
 */
public enum Operator {
 
    ADD {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    },
    MULTIPLY {
        @Override
        public int calculate(int a, int b) {
            return a * b;
        }
    },
    DIVIDE {
        @Override
        public int calculate(int a, int b) {
            if (b == 0) {
                throw new IllegalArgumentException("divisor must not be 0");
            }
            return a / b;
        }
    };
 
    public abstract int calculate(int a, int b);
 
}

从上面可以看到，我们基本可以像定义类一样来定义枚举。我们还可以定义属性、构造方法等：

package com.mikan;
 
/**
 * @author Mikan
 * @date 2015-08-29 12:06
 */
public enum Operator {
 
    ADD ("+") {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT ("-") {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    },
    MULTIPLY  ("*") {
        @Override
        public int calculate(int a, int b) {
            return a * b;
        }
    },
    DIVIDE ("/") {
        @Override
        public int calculate(int a, int b) {
            if (b == 0) {
                throw new IllegalArgumentException("divisor must not be 0");
            }
            return a / b;
        }
    };
 
    Operator (String operator) {
        this.operator = operator;
    }
 
    private String operator;
 
    public abstract int calculate(int a, int b);
 
    public String getOperator() {
        return operator;
    }
 
}

实现原理分析

既然可以像使用普通的类一样使用枚举，编译器究竟为我们做了些什么事呢？

一个枚举在经过编译器编译过后，变成了一个抽象类，它继承了java.lang.Enum；而枚举中定义的枚举常量，变成了相应的public static final属性，而且其类型就抽象类的类型，名字就是枚举常量的名字，同时我们可以在Operator.class的相同路径下看到四个内部类的.class文件com/mikan/Operator$1.class、com/mikan/Operator$2.class、com/mikan/Operator$3.class、com/mikan/Operator$4.class，也就是说这四个命名字段分别使用了内部类来实现的；同时添加了两个方法values()和valueOf(String)；我们定义的构造方法本来只有一个参数，但却变成了三个参数；同时还生成了一个静态代码块。

---

这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Operator[]类型返回。它相当于下面的代码：

public static com.mikan.Operator[] values() {
return (Operator[])$VALUES.clone();
}

---

这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Operator.valueOf()）,返回参数字符串表示的枚举常量，另外，这个方法的实现是，调用父类Enum的valueOf方法，并把类型强转成Operator。它相当于如下的代码：

public static com.mikan.Operator valueOf(String name) {
return (Operator)Enum.valueOf(Operator.class, name);
}

生成的内部类

实现内部类是继承自Operator，即

    ADD {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },

这就是说，我们定义的每个枚举常量，最终都生成了一个像上面这样的内部类。

构造方法为什么增加了两个参数？

有一个问题，构造方法我们明明只定义了一个参数，为什么生成的构造方法是三个参数呢？

从Enum类中我们可以看到，为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如ADD、SUBTRACT等，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始。在枚举常量初始化时，会自动为初始化这两个字段，设置相应的值，所以才在构造方法中添加了两个参数。即：

  com.mikan.Operator$1(String name, int ordinal, String operator);

另外三个枚举常量生成的内部类基本上差不多，这里就不重复说明了。

我们可以从Enum类的代码中看到，定义的name和ordinal属性都是final的，而且大部分方法也都是final的，特别是clone、readObject、writeObject这三个方法，这三个方法和枚举通过静态代码块来进行初始化一起，它保证了枚举类型的不可变性，不能通过克隆，不能通过序列化和反序列化来复制枚举，这能保证一个枚举常量只是一个实例，即是单例的，所以在effective java中推荐使用枚举来实现单例。

总结

枚举本质上是通过普通的类来实现的，只是编译器为我们进行了处理。每个枚举类型都继承自java.lang.Enum，并自动添加了values和valueOf方法。而每个枚举常量是一个静态常量字段，使用 内部类 实现，该内部类继承了枚举类。所有枚举常量都通过静态代码块来进行初始化，即在类加载期间就初始化。另外通过把clone、readObject、writeObject这三个方法定义为final的，同时实现时抛出相应的异常。这样保证了 每个枚举类型 及 枚举常量 都是不可变的。可以利用枚举的这两个特性来 实现线程安全的单例。