1.在没有枚举之前，我们如果需要一些常量，比如说，我们想用一些常量来代替订单的几种状态，如已下单未付款、已付款未发货、已发货未确认收货、已收货未评价、已评价。我们会定义一个用来装常量的类，比如：
package com.xdx.learn;
public class OrderConstant {
public static final int UNPAY=1;//未付款
public static final int UNDELIVER=2;//未发货
public static final int UNRECEIVE=3;//未收货
public static final int UNCOMMENT=4;//未评价
}
在其他地方调用的时候，我们直接通过OrderConstant .UNPAY就可以获取到这个常量。
2.有了枚举类型以后，我们会这样来写代码。
新建一个枚举类。
public enum OrderEnum {
UNPAY("unpay",1),UNDELIVER("undeliver",2),UNRECEIVE("unreceive",3),UNCOMMENT("uncomment",4);
private String key;
private int value;
private OrderEnum(String key,int value){
this.key=key;
this.value=value;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public static void main(String args[]){
System.out.println(OrderEnum.UNPAY.getKey());
System.out.println(OrderEnum.UNPAY.getValue());
}
}
上面就是一个枚举类，它有如下特点。
（1）它不用class修饰，而是用enum关键字来修饰。但是要知道的是，它本质上还是一个类。
（2）它的构造函数不能用public修饰，只能用private来修饰，也就是说，我们不能在外部实例化一个枚举类的对象。这让你想到了什么呢？是不是单例模式。
（3）UNPAY("unpay",1),UNDELIVER("undeliver",2),UNRECEIVE("unreceive",3),UNCOMMENT("uncomment",4);这几个都是该枚举类的对象（他们都是OrderEnum类型的），以静态常量的成员变量的形式存在于枚举类中。事实上，他们是public static final类型的，所以我们可以在类外部使用类名.成员变量，比如OrderEnum.UNPAY的形式来访问。
(4)一旦你定义了一个枚举类，则必须也将它的实例创建出来，即是上述的UNPAY("unpay",1)这些实例。实例的创建被简化了，只需要调用构造函数，不需要用new关键字。
其实，按照我的理解，上述的枚举类可以用以下的类来代替。
package com.xdx.learn;
public class OrderMulti {
private String key;
private int value;
private OrderMulti(String key,int value){
this.key=key;
this.value=value;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public static final OrderMulti UNPAY=new OrderMulti("unpay", 1);
public static final OrderMulti UNDELIVER=new OrderMulti("undeliver", 2);
public static final OrderMulti UNRECEIVE=new OrderMulti("unreceive", 3);
public static final OrderMulti UNCOMMENT=new OrderMulti("uncomment", 4);
public static void main(String args[]){
System.out.println(OrderMulti.UNPAY.getKey());
System.out.println(OrderMulti.UNPAY.getValue());
}
}
没错，枚举类就相当于一个带有多例（多例模式）的java类。只不过java的语法帮我们做了这些显式实例化的操作，并且以一种比较简单的语法来表示。就变成了enum了。
3.再深入一点，其实枚举类都是Enum类的子类，去查jdk源码，发现Enum是一个抽象的泛型类，其定义为public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable。事实上，上述的OrderEnum类，可以理解成这样的一个类。
public class OrderEnum extends Enum<OrderEnum>，没错，泛型的类型实参就是这个枚举类本身。
不过当你真的在eclipse里面敲入上面的一个类，会发现报错，因为Enum这个类是不可继承的，提示的错误是The type OrderEnum may not subclass Enum<A> explicitly。不能显式的继承Enum。jdk在编译阶段就拒绝了一个类去继承Enum，具体什么原因，怎么实现，我也不知道。我们只需要知道enum修饰的类，它的父类是Enum就行了。
既然如此，enum修饰的类也就不可以在继承其他的类了，因为java是单继承的。当然可以通过实现接口的方式去对enum类进行扩展。
由于枚举类继承自Enum，那么Enum里面的一些方法他也可以用。看如下代码，使用了几个比较常用的方法。
public static void main(String args[]){
System.out.println(OrderEnum.UNPAY.getKey());
System.out.println(OrderEnum.UNPAY.getValue());
//name()方法获取该枚举类实例的名称
System.out.println(OrderEnum.UNPAY.name());
//ordinal()方法获取该枚举类实例在所有实例中的排序，从0开始。
System.out.println(OrderEnum.UNPAY.ordinal());
//compareTo()方法比较两个枚举实例的排序，可认为是前者的ordinal-后者的ordinal的值。
System.out.println(OrderEnum.UNPAY.compareTo(OrderEnum.UNDELIVER));
System.out.println(OrderEnum.UNRECEIVE.compareTo(OrderEnum.UNDELIVER));
System.out.println(OrderEnum.UNCOMMENT.compareTo(OrderEnum.UNDELIVER));
//获取该枚举对象的类
System.out.println(OrderEnum.UNPAY.getDeclaringClass());
//验证枚举类的父类确实是Enum
System.out.println(OrderEnum.UNPAY.getDeclaringClass().getSuperclass());
System.out.println(OrderEnum.UNPAY.equals(OrderEnum.UNCOMMENT));
//遍历枚举类中实例
for(OrderEnum orderenum:OrderEnum.values()){
System.out.println(orderenum.getKey());
}
}
上述代码的运行结果为：
unpay
1
UNPAY
0
-1
1
2
class com.xdx.learn.OrderEnum
class java.lang.Enum
false
unpay
undeliver
unreceive
uncomment
4.只要将枚举理解成一个实现了多例模式的类，运用起来就不会有什么困难。但是也有人会问，我用第一种方式，即直接使用一个public static final int UNPAY=1。这样的常量。不是也可以实现枚举需要的功能吗？为何还大费周章去定义一个枚举类呢？我觉得是基于如下几方面考虑的。
（1）首先枚举类的类名可以有一定的指示作用，比如我们给一个枚举类命名为week，我们可以知道它应该就是代表星期，而在枚举之前，我们使用常量的容器类，往往只定义一个类，命名为类似于Constant这样的类，要去里面找寻其中的常量值是比较费劲的。
（2）当用枚举作为函数的形参的时候，能起到限定的作用。比如我有一个函数 ，我可以定义为void func(int x)，接受一些常量值。我也可以定义成void func(OrderEnum orderEnum)这样的形式。后者比前者的优点在于它限制了传入的参数只能是该枚举类的实例，而前者则可以传入任意整型。