源码系列(五)----java枚举类型详解

     之所以想要写一篇这样的文章，是因为我目前所做的项目中，实在是使用了太多的枚举类了，Spring与Mybatis的注解大量使用了枚举类，在我们的业务代码中也用来定义一些业务策略。然而我平时对于枚举类只是简单的使用，故打算写一篇这样的文章来总结一下。

     java的枚举类型有jdk1.5开始正式提供，用来定义一系列常量。

1、简单的枚举类例子

      我们先定义一个Color枚举类型，代码如下：

public enum Color {
    RED,YELLOW,GREEN
}

      格式如上所示，定义Color枚举类需要使用emum关键字，有些读者可能会有了异或：为什么称这个例子为一个枚举类？并没有使用class关键字啊。可以先别着急，这里先卖一个关子，后面会对此作出解释。

      内部RED，YELLOE， GREEN是当前枚举类Color的三个实例。

2、反编译查看 Color枚举类

      这里不要使用jd-gui或者intellij idea自带的反编译工具查看，它们为了更易使读者理解，隐藏了一些细节。我在这里使用了jdk自带的反编译命令查看。

     1、首先，将Color 枚举类编译为class文件，使用javac命令。

javac Color.java

     2、在当前目录中已经生成了Color.class文件

     先介绍一下javap命令的使用方法

#语法
javap [命令选项] class文件名

#命令选项
-help  --help  -?        输出此用法消息
-version                 版本信息
-v  -verbose             输出附加信息
-l                       输出行号和本地变量表
-public                  仅显示公共类和成员（可以不加）
-protected               显示受保护的/公共类和成员
-package                 显示程序包/受保护的/公共类和成员 (默认)
-p  -private             显示所有类和成员
-c                       对代码进行反汇编
-s                       输出内部类型签名
-sysinfo                 显示正在处理的类的系统信息 (路径, 大小, 日期, MD5 散列)
-constants               显示最终常量
-classpath         指定查找用户类文件的位置
-cp                指定查找用户类文件的位置
-bootclasspath     覆盖引导类文件的位置

       这里我们执行如下命令：

      可以看到Color实际上是一个继承自Enum类的final类，所以才说它是枚举类，使用final修饰，意味着Color已经不允许被继承了。RED、YELLOE、GREEN是Color内部的三个静态实例变量。

      看到这样是类结构，是不是有一丝熟悉？没错，就是设计模式中的单例模式的形式，是饿汉模式的一种实现。如果Color中只有一个实例成员的话，加上那就是妥妥的单例模式了，只是没有通过类似getInstance()获取实例对象。构造函数使用的是privete方法因为实例成员使用的public修饰，直接通过成员变量名获取，因为使用了同样使用final进行修饰，直接获取就可以了。因为使用了static修饰，依托于jvm的类加载过程中的实例化，而不用担心多线程问题。

      可以看到，Color类存在一个Color类型的$VALUES数组，还存在一个values方法和一个valueOf方法，前者就是返回的$VALUES的内容，即RED、YELLOE、GREEN组成的Color数组；后者传入的是一个St

String,从而根据String获取相应的枚举实例，如：

      实际上，枚举类还可以添加自有的方法，甚至还可以是main方法。对于复杂一些的枚举类，最后的枚举实例需要添加“;”，还需要添加自有的构造方法：

public enum Color1 {
    RED("red",1),YELLOW("red",2),BLUE("blue",3);

    private String name;
    private int num;

    Color1(String name, int num) {
        this.name = name;
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public int getNum() {
        return num;
    }
}

      反编译后类结构如下：

public final class Color1 extends java.lang.Enum {
  public static final Color1 RED;
  public static final Color1 YELLOW;
  public static final Color1 BLUE;
  private java.lang.String name;
  private int num;
  private static final Color1[] $VALUES;
  public static Color1[] values();
  public static Color1 valueOf(java.lang.String);
  private Color1(java.lang.String, int);
  public java.lang.String getName();
  public int getNum();
  static {};
}

     可以看到，对于构造方法反编译后，还是private修饰的。上面的代码中我的写法并没有添加修饰符，实际上枚举类的构造方法不允许使用public或者protected进行修饰，否则会编译报错。

3、JDK Enum类的结构

      因为所有的枚举类都是Enum的子类，抛开Enum类谈枚举类是不现实的。

public abstract class Enum> implements Comparable, Serializable {

    // 当前枚举实例的name,如RED实例的name属性为“RED”
    private final String name;

    // 获取name的值
    public final String name() {
        return name;
    }

    // 当前枚举实例在定义时的位置，其实也就是在$value数组中的位置
    private final int ordinal;

    // 获取ordinal的值，普通开发不会使用，在EnumSet和EnumMap中会有使用
    public final int ordinal() {
        return ordinal;
    }

    // Enum中唯一的构造函数
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

    // 和name()一样是获取name的值，相较于name方法，更推荐使用本方法
    public String toString() {
        return name;
    }

    // 比较两个枚举实例是否相等，因为枚举实例是static的，因此使用等号比较就可以了
    public final boolean equals(Object other) {
        return this==other;
    }

    // 返回当前枚举实例的hash码
    public final int hashCode() {
        return super.hashCode();
    }

    // 每一个枚举实例都是唯一的，因此不允许对其进行克隆
    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    // 比较两个枚举实例，即比较两个枚举实例的ordinal值，也就是比较它们的定义顺序
    public final int compareTo(E o) {
        Enum other = (Enum)o;
        Enum 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 getDeclaringClass() {
        Class clazz = getClass();
        Class zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class)clazz : (Class)zuper;
    }

    // 跟前面反编译的valueOf(String name)不同，这个多了一个类参数，推测子类生成的方法同样使用的这个方法
    public static > T valueOf(Class 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);
    }

    // 不支持这两个方法
    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");
    }
}

     扩展：

      EnumSet是一种特殊的Set集合，其中的元素必须来自一个枚举类。

      EnumMap是一种特殊的Map，其中的键必须来自一个枚举类。