Java枚举

前言：

Java 枚举，是JDK1.5引入的，不同于class 类，是由 enum 修饰的类，在java中一个类可以创建多个实例，枚举也不意外可以拥有多个实例，只是不是通过 new 的方式创建新的实例，而是在我们编写 enum 时，就创建的实例，枚举类的构造器，默认是 private 的，而且只能是 privae，因为枚举的实例不是由外界来创建，而是在使用是通过 jvm 来创建的。

简单示例：

1. 我们创建一个 加减乘除 的枚举类，以及一个test：
2. 讲解：
   a. 枚举类的初始化是在第一次引用的时候，将全部的枚举项初始化为示例，也只能这样创建
   b. 枚举类中有个默认参数 name，当我们不设置name 值时默认是枚举项的变量名

/**
 * 计算枚举
 */
public enum Calculation {

    // 实例：加,减,乘,除;
    ADD,SUBTRACT, MULTIPLY, DIVIDE;

    // 修饰符默认只能是private
    Calculation(){
        System.out.println("实例化");
    }
}

// 测试类
public class Test {

    public static void main(String[] args) {
        System.out.println("执行 main 方法");
        System.out.println(Calculation.ADD.name());
        System.out.println(Calculation.SUBTRACT.name());
        System.out.println(Calculation.MULTIPLY.name());
        System.out.println(Calculation.DIVIDE.name());
    }
}

打印结果：

2. 下面演示一下，如何给不同的枚举项赋值，与此同时构造方法也要相同的操作，其实后续创建枚举的实例时类似于 new Calculation( String name, String Symbol)， 我们加入变量 name，symbol：

/**
 * 计算枚举
 */
public enum Calculation {

    // 实例：加,减,乘,除;
    ADD("加","+"),SUBTRACT("减","-"), MULTIPLY("乘","*"), DIVIDE("除","/");

    // name 可以省略不写，后面会讲
    private String name;

    private String symbol;

    Calculation(String name, String symbol) {
        this.name = name;
        this.symbol = symbol;
        System.out.println("实例化,name:" + name + ",symbol:" + symbol);
    }

    public String symbol() {
        return symbol;
    }
}


// 测试类
public class Test {

    public static void main(String[] args) {
        System.out.println("执行 main 方法");
        System.out.println("name："+ Calculation.ADD.name() +",symbol:"+Calculation.ADD.symbol());
        System.out.println("name："+ Calculation.SUBTRACT.name() +",symbol:"+Calculation.SUBTRACT.symbol());
        System.out.println("name："+ Calculation.MULTIPLY.name() +",symbol:"+Calculation.MULTIPLY.symbol());
        System.out.println("name："+ Calculation.DIVIDE.name() +",symbol:"+Calculation.DIVIDE.symbol());
    }
}

打印结果：

枚举的父类Enum：

为什么我们在上面枚举类中没有定义 name 变量也可以使用，是因为所有的枚举默认都继承了 Enum类，它其中包含了 name 和 ordinal 变量， 作为子类，自然可以使用父类的变量了，我们来看一下 Enum
代码 （java.lang.Enum）：

public abstract class Enum<E extends java.lang.Enum<E>>
        implements Comparable<E>, Serializable {



    //枚举常量的名称
    private final String name;

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

    // 这个枚举常数的序数（它的位置在枚举声明中，其中分配了初始常量零的序数）。
    private final int ordinal;

    // 获取枚举的序数
    public final int ordinal() {
        return ordinal;
    }

    /**
     *唯一的构造器。程序员不能调用这个构造函数。
     *它由编译器发出的代码用于响应枚举类型声明。
     *@param name-此枚举常量的名称，它是标识符用来申报。
     *@param ordinal-此枚举常量的序号（其位置在枚举声明中，其中分配了初始常量零的序数）。
     */
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

    // toString
    public String toString() {
        return name;
    }

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

    // hashCode
    public final int hashCode() {
        return super.hashCode();
    }

    /**
     *抛出CloneNotSupportedException。这保证枚举
     *从来没有克隆过，这是保持它们的“单一性”所必需的状态。
     *
     *@return（永不返回）
     */
    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    /**
     *将此枚举与指定对象的顺序进行比较。返回负整数、零或正整数，
     * 因为此对象小于大于、等于或大于指定对象。
     *
     *枚举常量只能与相同的枚举类型。由它实现的自然秩序方法是声明常量的顺序。
     */
    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;
    }

    /**
     * 返回与此枚举常量对应的类对象枚举类型。
     * 两个枚举常量e1和e2是相同的枚举类型if和only if e1.getDeclaringClass（）==e2.getDeclaringClass（）。
     *（此方法返回的值可能与返回的值不同）
     * 对于常量特定类主体。
     *
     * @返回与此枚举常量对应的类对象
     * 枚举类型
     */
    @SuppressWarnings("unchecked")
    public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == java.lang.Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
    }

    // 根据枚举类型 和 枚举名称 获取对应的枚举
    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);
    }

    /**
     *枚举类不能有finalize方法。
     */
    protected final void finalize() { }

    /**
     *防止默认反序列化
     */
    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");
    }
}

上面代码中已经解释了很详细, 我们需要注意的是：

1. name：默认是枚举常量的名称，也可以赋值， name() 方法不可以被重写
2. ordinal：是每个枚举项在枚举类出现的先后位置，从0开始， 该变量可以用于 compareTo 方法

枚举项的其它用法：

枚举项中也可以用于实现枚举中的抽象方法【一般比较少见】，上代码：

/**
 * 计算枚举
 */
public enum Calculation {

    ADD("加","+"){
        public void print() { System.out.println("name："+ name() +",symbol:"+symbol()); }},

    SUBTRACT("减","-"){
        public void print() { System.out.println("name："+ name() +",symbol:"+symbol()); }},

    MULTIPLY("乘","*"){
        public void print() { System.out.println("name："+ name() +",symbol:"+symbol()); }},

    DIVIDE("除","/"){
        public void print() { System.out.println("name："+ name() +",symbol:"+symbol()); }};

    private String name;

    private String symbol;

    Calculation(String name, String symbol) {
        this.name = name;
        this.symbol = symbol;
    }

    public String symbol() {
        return symbol;
    }

    // 抽象方法，用于枚举项实现
    public abstract void print();
}


// 测试类：
public class Test {

    public static void main(String[] args) {
        Calculation.ADD.print();
        Calculation.ADD.print();
        Calculation.SUBTRACT.print();
        Calculation.MULTIPLY.print();
        Calculation.DIVIDE.print();
    }
}

总结：

对于枚举的理解需要区分 普通的类，它的实例对象时由自己定义 jvm 创建【《Effective Java》中建议在单例模式中使用】，其他的就是一些属性常用方法上的理解，并不是很难理解，仅仅是见过没见过，用过没用过的区别。 在工作中用上几次就基本OK了，这里博主也仅仅是记录一下