Java 枚舉：理解枚舉本質

C 語言中可以這樣來定義枚舉

enum color {        RED=0, GREEN, BLUE, YELLOW} col;

關鍵字 enum 定義枚舉，在定義枚舉的同時，聲明該枚舉變數 col.

注意：C 語言中枚舉成員的值是根據上下文自動加 1 的（GREEN = 1, BLUE = 2 等）。

C 語言中 switch 語句支援枚舉類型

#include<stdio.h>int main() {    enum color {        RED=0, GREEN, BLUE, YELLOW    } col;    int cl;    printf("0=red,1=green,2=blue,3=yellow. seclect:\n");    scanf("%d",&cl);    col=(enum color) cl;    switch(col) {        case RED:            printf("the color is red\n");            break;        case GREEN:            printf("the color is green\n");            break;        case BLUE:             printf("the color is blue\n");            break;        case YELLOW:            printf("the color is yellow\n");            break;        defalut:            printf("no this color\n");            break;    }    return 0;}

那麼，Java 裡面的枚舉與其類似，但是又不是完全一樣。

Java 語言中定義枚舉也是使用關鍵字 enum

public enum Color {RED, GREEN, BLUE, YELLOW;}

上述定義了一個枚舉類型 Color（可以說是類，編譯之後是 Color.class）.

上面的定義，還可以改成下面的這種形式

public enum Color {RED(), GREEN(), BLUE(), YELLOW();}

到這裡你就會覺得迷茫（如果你是初學者的話），為什麼這樣子也可以？

其實，枚舉的成員就是枚舉對象，只不過他們是靜態常量而已。

使用 javap 命令（javap 檔案名稱<沒有尾碼.class>）可以反編譯 class 檔案，如下：

我們可以使用普通類來類比枚舉，下面定義一個 Color 類。

public class Color {private static final Color RED = new Color();private static final Color GREEN = new Color();private static final Color BLUE = new Color();private static final Color YELLOW = new Color();}

對比一下，你就明白了。

如果按照這個邏輯，是否還可以為其添加另外的構造方法？答案是肯定的！

public enum Color {RED("red color", 0), GREEN("green color", 1), BLUE("blue color", 2), YELLOW("yellow color", 3);Color(String name, int id) {_name = name;_id = id;}String _name;int _id;}

為 Color 聲明了兩個成員變數，並為其構造帶參數的構造器。

如果你這樣建立一個枚舉

public enum Color {RED("red color", 0), GREEN("green color", 1), BLUE("blue color", 2), YELLOW("yellow color", 3);}

編譯器就會報錯

The constructor EnumDemo.Color(String, int) is undefined

到此，你就可以明白，枚舉和普通類基本一致（但是不完全一樣）。

對於類來講，最好將其成員變數私人化，然後，為成員變數提供 get、set 方法。

按照這個原則，可以進一步寫好 enum Color.

public enum Color {RED("red color", 0), GREEN("green color", 1),BLUE("blue color", 2), YELLOW("yellow color", 3);Color(String name, int id) {_name = name;_id = id;}private String _name;private int _id;public void setName(String name) {_name = name;}public void setId(int id) {_id = id;}public String getName() {return _name;}public int getId() {return _id;}}

但是，java 設計 enum 的目的是提供一組常量，方便使用者設計。

如果我們冒然的提供 set 方法（外界可以改變其成員屬性），好像是有點違背了設計的初衷。

那麼，我們應該捨棄 set 方法，保留 get 方法。

public enum Color {RED("red color", 0), GREEN("green color", 1),BLUE("blue color", 2), YELLOW("yellow color", 3);Color(String name, int id) {_name = name;_id = id;}private String _name;private int _id;public String getName() {return _name;}public int getId() {return _id;}}

普通類，我們可以將其執行個體化，那麼，能否執行個體化枚舉呢？

在回答這個問題之前，先來看看，編譯之後的 Color.class 檔案

public static enum Color {RED("red color", 0), GREEN("green color", 1),BLUE("blue color", 2), YELLOW("yellow color", 3);private String _name;private int _id;private Color(String name, int id) {this._name = name;this._id = id;}public String getName() {return this._name;}public int getId() {return this._id;}}

可以看出，編譯器淘氣的為其構造方法加上了 private，那麼也就是說，我們無法執行個體化枚舉。

所有枚舉類都繼承了 Enum 類的方法，包括 toString 、equals、hashcode 等方法。

因為
equals、hashcode 方法是 final 的，所以不可以被枚舉重寫（只可以繼承）。

但是，可以重寫 equals 方法。

關於 Enum 源碼，詳見附錄！

那麼，使用 Java 的不同類來類比一下枚舉，大概是這個樣子

package mark.demo;import java.util.ArrayList;import java.util.List;public class Color {private static final Color RED = new Color("red color", 0);private static final Color GREEN = new Color("green color", 1);private static final Color BLUE = new Color("blue color", 2);private static final Color YELLOW = new Color("yellow color", 3);private final String _name;private final int _id;private Color(String name, int id) {_name = name;_id = id;}public String getName() {return _name;}public int getId() {return _id;}public static List<Color> values() {List<Color> list = new ArrayList<Color>();list.add(RED);list.add(GREEN);list.add(BLUE);list.add(YELLOW);return list;}@Overridepublic String toString() {return "the color _name=" + _name + ", _id=" + _id;}}

附錄

Enum.java

/* * %W% %E% * * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package java.lang;import java.io.Serializable;import java.io.IOException;import java.io.InvalidObjectException;import java.io.ObjectInputStream;import java.io.ObjectStreamException;/** * This is the common base class of all Java language enumeration types. * * @author  Josh Bloch * @author  Neal Gafter * @version %I%, %G% * @since   1.5 */public abstract class Enum<E extends Enum<E>>        implements Comparable<E>, Serializable {    /**     * The name of this enum constant, as declared in the enum declaration.     * Most programmers should use the {@link #toString} method rather than     * accessing this field.     */    private final String name;    /**     * Returns the name of this enum constant, exactly as declared in its     * enum declaration.     *      * <b>Most programmers should use the {@link #toString} method in     * preference to this one, as the toString method may return     * a more user-friendly name.</b>  This method is designed primarily for     * use in specialized situations where correctness depends on getting the     * exact name, which will not vary from release to release.     *     * @return the name of this enum constant     */    public final String name() {return name;    }    /**     * The ordinal of this enumeration constant (its position     * in the enum declaration, where the initial constant is assigned     * an ordinal of zero).     *      * Most programmers will have no use for this field.  It is designed     * for use by sophisticated enum-based data structures, such as     * {@link java.util.EnumSet} and {@link java.util.EnumMap}.     */    private final int ordinal;    /**     * Returns the ordinal of this enumeration constant (its position     * in its enum declaration, where the initial constant is assigned     * an ordinal of zero).     *      * Most programmers will have no use for this method.  It is     * designed for use by sophisticated enum-based data structures, such     * as {@link java.util.EnumSet} and {@link java.util.EnumMap}.     *     * @return the ordinal of this enumeration constant     */    public final int ordinal() {return ordinal;    }    /**     * Sole constructor.  Programmers cannot invoke this constructor.     * It is for use by code emitted by the compiler in response to     * enum type declarations.     *     * @param name - The name of this enum constant, which is the identifier     *               used to declare it.     * @param ordinal - The ordinal of this enumeration constant (its position     *         in the enum declaration, where the initial constant is assigned     *         an ordinal of zero).     */    protected Enum(String name, int ordinal) {this.name = name;this.ordinal = ordinal;    }    /**     * Returns the name of this enum constant, as contained in the     * declaration.  This method may be overridden, though it typically     * isn't necessary or desirable.  An enum type should override this     * method when a more "programmer-friendly" string form exists.     *     * @return the name of this enum constant     */    public String toString() {return name;    }    /**     * Returns true if the specified object is equal to this     * enum constant.     *     * @param other the object to be compared for equality with this object.     * @return  true if the specified object is equal to this     *          enum constant.     */    public final boolean equals(Object other) {         return this==other;    }    /**     * Returns a hash code for this enum constant.     *     * @return a hash code for this enum constant.     */    public final int hashCode() {        return super.hashCode();    }    /**     * Throws CloneNotSupportedException.  This guarantees that enums     * are never cloned, which is necessary to preserve their "singleton"     * status.     *     * @return (never returns)     */    protected final Object clone() throws CloneNotSupportedException {throw new CloneNotSupportedException();    }    /**     * Compares this enum with the specified object for order.  Returns a     * negative integer, zero, or a positive integer as this object is less     * than, equal to, or greater than the specified object.     *      * Enum constants are only comparable to other enum constants of the     * same enum type.  The natural order implemented by this     * method is the order in which the constants are declared.     */    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;    }    /**     * Returns the Class object corresponding to this enum constant's     * enum type.  Two enum constants e1 and  e2 are of the     * same enum type if and only if     *   e1.getDeclaringClass() == e2.getDeclaringClass().     * (The value returned by this method may differ from the one returned     * by the {@link Object#getClass} method for enum constants with     * constant-specific class bodies.)     *     * @return the Class object corresponding to this enum constant's     *     enum type     */    public final Class<E> getDeclaringClass() {Class clazz = getClass();Class zuper = clazz.getSuperclass();return (zuper == Enum.class) ? clazz : zuper;    }    /**     * Returns the enum constant of the specified enum type with the     * specified name.  The name must match exactly an identifier used     * to declare an enum constant in this type.  (Extraneous whitespace     * characters are not permitted.)      *     * @param enumType the <tt>Class</tt> object of the enum type from which     *      to return a constant     * @param name the name of the constant to return     * @return the enum constant of the specified enum type with the     *      specified name     * @throws IllegalArgumentException if the specified enum type has     *         no constant with the specified name, or the specified     *         class object does not represent an enum type     * @throws NullPointerException if <tt>enumType</tt> or <tt>name</tt>     *         is null     * @since 1.5     */    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 const " + enumType +"." + name);    }    /**      * prevent default deserialization      */    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");    }    /**     * enum classes cannot have finalize methods.     */    protected final void finalize() { }}