什么是枚举

       Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是：

在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠.。枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举。

使用枚举

enum类型出现之前的写法

       在Java5之前，其实是没有enum的，所以先来看一下Java5之前对于枚举的使用场景该怎么解决？这里我看到了一片关于在Java 1.4之前的枚举的设计方案：

设计方案1：

import java.util.Enumeration;
 public class Months {
   public static String [] months = { "JAN", "FEB" , "MAR" };
   public static Enumeration elements() {
     return new MonthsEnumerator();
   }
 }
​
 class MonthsEnumerator implements Enumeration {
   private int idx = 0;
   public /*static*/ boolean hasMoreElements() {
     return (idx < Months.months.length);
   }
   public /*static*/ Object nextElement() {
     return Months.months[idx++];
   }
 }

设计方案2：

/**
 * 这个是比较规范的一个设计：
 * 它是线程安全的，不可变的，并且很好的解决了序列化中的多实例问题
 * 但是它仍然无法规避一个类可以被多个ClassLoader加载，这样仍然会出现多个实例
 * 因为按照虚拟机规范：如果相同的一个类同时被多个类加载器加载，虚拟机会认为这几个类不是同一个类，会共存
 */
public class Month implements Comparable, java.io.Serializable {
​
 public static final Month JAN = new Month("January");
 public static final Month FEB = new Month("February", 28);
 public static final Month MAR = new Month("March");
 public static final Month APR = new Month("April", 30);
 public static final Month MAY = new Month("May");
 public static final Month JUN = new Month("June", 30);
 public static final Month JUL = new Month("July");
 public static final Month AUG = new Month("August");
 public static final Month SEP = new Month("September", 30);
 public static final Month OCT = new Month("October");
 public static final Month NOV = new Month("November", 30);
 public static final Month DEC = new Month("December");
​
 private static final Month[] MONTH_ARRAY =
 { JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC };
​
 private static int count = 0;
​
 private final String name;
 private final int number;
 private final int days;
​
 private Month(String name) {
   this(name, 31);
 }
 private Month(String name, int days) {
   this.name = name;
   this.days = days;
   this.number = ++count;
 }
 public String getName() {
   return name;
 }
 public String getAbbev() {
   return name.substring(0, Math.min(3, getName().length()));
 }
 public int getNumber() {
   return number;
 }
 public int getDays() {
   return days;
 }
 public String toString() {
   return name;
 }
 @Override
 public int compareTo(Object o) {
   return getNumber() - ((Month) o).getNumber();
 }
​
 //readResolve这个方法目的是解决序列化的单例问题
 //保证该类对象在序列化后，再进行反序列化时使用在jvm中只有一个对象
 Object readResolve() throws java.io.ObjectStreamException {
   return MONTH_ARRAY[number - 1];
 }
}

       类似的设计方案还有很多，其实从这些设计中都可以看出，在JDK的枚举类型出现之前，主要依托的是Enumeration这个枚举器接口，具体的设计需要手动去实现，而实现了Enumeration接口的类负责对设计的类似枚举类进行迭代。但是这些设计都有这样或那样的不足，可能是性能上的，可能是使用上的，甚至可能是线程安全上的。

JDK1.5以后的用法

       在JDK1.5以后，JDK出了enum类型，这个改动大大方便了我们在日常开发中对于枚举的设计与编码。它的写法极其简单，例如最简单的一个月份枚举：

public enum Month{
 JAN, FEB, MAR;//...直到12月份
 //该方法可以有，可以没有，如果没有其他逻辑，完全可以不写
 public void method () { 
 }
}

       这样我们一个枚举类就写完了，很简洁，很明了。这个就是引入enum的一个好处，我们不需要再关系具体的枚举类的设计，只要enum定义，把需要的枚举值挨个写入即可。

       如果我们在定义枚举常量的时候额外传入一些参数，可以这么写：

public enum RGB {
 RED(1),GREEN(2), BLUE(3);
 private int index;
 //构造方法
 //但是构造方法的修饰符有限制，不可以是public，只能private
 //实际上即使不写private，默认的也是private
 private RGB(int index) {
   this.index = index;
 }
 //普通方法
 public static int getIndex(RGB rgb) {
   return rgb.getIndex();
 }
 //getter 和 setter方法
 ...
}

       它还有很多用法，比如：可以重写一些从父类继承过来的方法，可以实现接口，甚至可以使用接口来组织枚举，具体可以参靠：Java枚举的用法介绍--Hollis。

       其实从上面这些写法来看，我们在使用的时候没有必要过分在意它是enum 还是class，大多的使用方式都跟普通的Java类没有什么区别，唯独就是在写一些枚举常量的时候，写法有些迥异，但是除此之外，其他方面几乎完全一样：一样可以实现接口，一样需要实现接口中的方法，一样可以重写父类方法(如：toString)，甚至一样可以有构造方法。所以仅仅就使用来说，跟传统开发上几乎没有什么区别。

       这里唯一需要注意的就是构造函数的修饰符问题，因为enum在JDK中其实就是被设计成了单例模式，所以是不允许外部对其进行实例化的，枚举类型的实例化其实都是JVM帮我们完成，它在加载的时候就会帮我们实例化。

原理

       enum在JDK中实际的实现到底是怎么做的，这里借助cfr工具，这是一个反编译工具包，可以到cfr网站去下载，我之前下载的版本是cfr-0.132.jar，现在都已经又更新了，这里先以一个最最简单的枚举类为例，来看一下反编译后的源码：

public enum RGB {
 RED, GREEN, BLUE
}

然后通过cfr工具反编译：

//cfr其实就是一个jar包，以正常的java -jar就能运行，然后传入指定的class文件
//其后还可以指定一些参数，可以用--help查阅各个参数的介绍：
root@ubuntu:# java -jar ../cfr_0_132.jar --help
CFR 0_132
 --aexagg                         (boolean) 
 --aggressivesizethreshold        (int >= 0)  default: 15000
 --allowcorrecting                (boolean)  default: true
 --analyseas                      (One of [JAR, WAR, CLASS]) 
 --arrayiter                      (boolean)  default: true if class file from version 49.0 (Java 5) or greater
 --caseinsensitivefs              (boolean)  default: false
 --clobber                        (boolean) 
 --collectioniter                 (boolean)  default: true if class file from version 49.0 (Java 5) or greater
 --commentmonitors                (boolean)  default: false
 --comments                       (boolean)  default: true
 --decodeenumswitch               (boolean)  default: true if class file from version 49.0 (Java 5) or greater
 --decodefinally                  (boolean)  default: true
 --decodelambdas                  (boolean)  default: true if class file from version 52.0 (Java 8) or greater
 --decodestringswitch             (boolean)  default: true if class file from version 51.0 (Java 7) or greater
 --dumpclasspath                  (boolean)  default: false
 --eclipse                        (boolean)  default: true
 --elidescala                     (boolean)  default: false
 --extraclasspath                 (string) 
 --forcecondpropagate             (boolean) 
 --forceexceptionprune            (boolean) 
 --forcereturningifs              (boolean) 
 --forcetopsort                   (boolean) 
 --forcetopsortaggress            (boolean) 
 --forloopaggcapture              (boolean) 
 --hidebridgemethods              (boolean)  default: true
 --hidelangimports                (boolean)  default: true
 --hidelongstrings                (boolean)  default: false
 --hideutf                        (boolean)  default: true
 --ignoreexceptions               (boolean)  default: false
 --innerclasses                   (boolean)  default: true
 --j14classobj                    (boolean)  default: false if class file from version 49.0 (Java 5) or greater
 --jarfilter                      (string) 
 --labelledblocks                 (boolean)  default: true
 --lenient                        (boolean)  default: false
 --liftconstructorinit            (boolean)  default: true
 --methodname                     (string) 
 --outputdir                      (string) 
 --outputpath                     (string) 
 --override                       (boolean)  default: true if class file from version 50.0 (Java 6) or greater
 --pullcodecase                   (boolean)  default: false
 --recover                        (boolean)  default: true
 --recovertypeclash               (boolean) 
 --recovertypehints               (boolean) 
 --relinkconststring              (boolean)  default: true
 --removebadgenerics              (boolean)  default: true
 --removeboilerplate              (boolean)  default: true
 --removedeadmethods              (boolean)  default: true
 --removeinnerclasssynthetics     (boolean)  default: true
 --rename                         (boolean)  default: false
 --renamedupmembers
 --renameenumidents
 --renameillegalidents 
 --renamesmallmembers             (int >= 0)  default: 0
 --showinferrable                 (boolean)  default: false if class file from version 51.0 (Java 7) or greater
 --showops                        (int >= 0)  default: 0
 --showversion                    (boolean)  default: true
 --silent                         (boolean)  default: false
 --skipbatchinnerclasses          (boolean)  default: true
 --stringbuffer                   (boolean)  default: false if class file from version 49.0 (Java 5) or greater
 --stringbuilder                  (boolean)  default: true if class file from version 49.0 (Java 5) or greater
 --sugarasserts                   (boolean)  default: true
 --sugarboxing                    (boolean)  default: true
 --sugarenums                     (boolean)  default: true if class file from version 49.0 (Java 5) or greater
 --tidymonitors                   (boolean)  default: true
 --tryresources                   (boolean)  default: true if class file from version 51.0 (Java 7) or greater
 --usenametable                   (boolean)  default: true

如果直接使用cfr运行，不添加任何参数，得到的结果可能是这样的：

root@ubuntu:# java -jar ../cfr_0_132.jar RGB.class
/*
 * Decompiled with CFR 0_132.
 */
public enum RGB {
 RED,
 GREEN,
 BLUE;

 private RGB() {
 }
}

       可以看到，基本上没有啥变化，就是加了一个私有的构造函数，这不是想要的结果，其实这里cfr对于常见的一些枚举，自动拆装箱这种它语法糖反编译的时候保留了语法糖效果，我们现在需要的是将这种语法糖的效果去除掉，可以在上面的help结果中找到一个--sugarenums，看英文就知道是enum的语法糖，它默认是true，现在在反编译的时候将其设置成false，再来看结果：

root@ubuntu:# java -jar ../cfr_0_132.jar RGB.class --sugarenums false
/*
 * Decompiled with CFR 0_132.
 */
public final class RGB
extends Enum<RGB> {
 public static final /* enum */ RGB RED = new RGB();
 public static final /* enum */ RGB GREEN = new RGB();
 public static final /* enum */ RGB BLUE = new RGB();
 private static final /* synthetic */ RGB[] $VALUES;
​
 public static RGB[] values() {
   return (RGB[])$VALUES.clone();
 }
​
 public static RGB valueOf(String string) {
   return Enum.valueOf(RGB.class, string);
 }
​
 private RGB() {
   super(string, n);
 }
​
 static {
   $VALUES = new RGB[]{RED, GREEN, BLUE};
 }
}

       这个就很明显了，可以看到它实际上继承了一个叫Enum的类，并且之前我们定义的RGB枚举类现在变成了一个class了，而且是final类型的，所以无法被继承。这个Enum类在Java中我们是无法自己直接去继承的，否则会报错，它的JDK源码中有说明：无法直接继承Enum，必须通过它的子类才可以手动继承，否则就要通过这种enum类的定义方式让编译器帮我们实现直接继承的效果。

       通过反编译可以发现，其实enum就是一个语法糖，真正的操作实际上在编译器编译之后的内容。也就是说我们虽然在编码上很简洁明了，但是更多的工作其实都是编译器帮我们完成了。以这里RGB的枚举类为例：

• 首先我们自己定义的enum都会转换成一个final class，类名与我们定义的枚举名相同，并且继承自Enum类，而且泛型同样是RGB类型。

• 枚举中我们罗列的枚举常量，实际上都是RGB该类本身类型的常量。

• 它会默认帮我们生成三个方法：私有构造函数，valueOf方法以及values方法

• 会有一个静态RGB类型的数组常量，叫$VALUES，它里面存储就是枚举中的那些常量内容

       所以现在反过来再去看以下前面关于enum用法的介绍，大致就能看明白了，为什么既可以直接写枚举常量，也可以在枚举常量中添加参数，这一切都是因为枚举常量的类型实际上就是枚举类本身，所以如果传入一些参数时，我们需要指定它的构造函数，编译器默认帮我们生成的是无参的构造函数。

枚举的好处

简化代码

首先一个很明显的感触就是代码量明显减少了，结合前面介绍的在JDK1.5之前的时候，如果需要用到枚举，不同的人会有不同的设计，虽然设计的方式很多种，但是每一种都会有这样或那样的缺陷，而且大多数时候，程序员的编码水平参差不齐，所以如果在没有enum的时候，对于枚举这块的代码设计可能性能上或者说效果上有很大差异。

enum的引入，统一了一个编码规范，无论如何，最起码在枚举的编写上是处于一个水平线的，而且语法极其简单，几乎见名知意，没有什么很难以理解的地方，写出的代码简洁明了，于开发甚至是后期维护上都有很大的好处。

线程安全

       前面说过枚举类型的实例化不是由程序员自己完成的，而是由虚拟机来做的，在枚举被加载到虚拟机之后就会对其进行实例化，这一步程序员是无感知的，可以看上面它反编译之后的代码，类的内部几乎全部都是static，这也就是说，当真正第一次使用到的时候，虚拟机会对其进行初始化、类加载操作，这个过程是线程安全的，这是Java虚拟机明确规定的，所以说这一步的线程安全有虚拟机来保障是决定可靠的。

序列化安全

       前面在介绍enum出现之前的一些设计方案中，第二种就已经考虑到了序列化全的问题，它添加了readResolve方法，为的就是解决在单例模式下，通过序列化后仍然可以绕过常规检查生成多个相同类型的实例情况。关于序列化的分析，可以参考Java序列化。加入了readResolve方法后在反序列化的时候既可以通过该方法自行指定返回一个已经存在与虚拟机内部的对象了，从而避免了因反射调用存在的风险问题。

       在使用了enum之后，序列化安全的保障就完全不需要开发人员去关心了，它同样是虚拟机保障的，因为Java的序列化规定，对于enum类型的对象，在序列化的时候只是保存了一个名字，当再次进行反序列化的时候，它会根据这个名字到虚拟机中去找这个enum对象，这期间的writeObject，readObject等等一系列调用全部禁用，所以说枚举是序列化安全的。