关于java枚举使用和理解。

前言

在介绍枚举之前，先说说另外一个名词:［魔法数字］。魔法数字，是指在代码中直接出现的数值。
如：user.setStatus(1);
其中的数值1即为［魔法数字］，你很难直观的理解1所代表的含义。至少第一眼，你会疑惑1代表的是什么。
为了避免这点，在开发时，我想你会添加注释。

虽然注释是一件好事情，但是如果代码本身就能很好的自说明，我想你一定非常乐意不写这个注释。因为它不会让你有任何心理负担。

另外有一个想法我觉得不错：
当你能把代码做到很好的抽象时 ——［这时代码已经简洁了不少］
当你在定义方法名/变量名时能做到很好的自说明 ——［这时大部分代码，你已经一看就能明白了］
最后，再加上适当的注释。我想这代码，肯定很有艺术感。

PS：写代码时，对每一个变量的命名都请仔细思考，慎重。

而我的理解，枚举的诞生就是为了更好的解决上面的问题，提高代码的自说明。

另外枚举还有一个非常重要的好处：编译期间检查问题，数据的校验(方法参数定义的使用)等等。
这些在文章后面会一一提到。

言归正传

JAVA枚举（enum），JDK 1.5之后引入，存在于java.lang包内。它（enum）与class，interface的地位相同，用来定义枚举类。实际上枚举类是一个特殊的类，它也可以定义自己的方法，属性，构造器等，甚至可以实现接口。

api文档中，java.lang.Enum描述（大致）:

//所有Java语言枚举类型的公共基本类。(注意Enum为抽象类)
public abstract class Enum<E extends Enum<E>>extends Object implements Comparable<E>, Serializable{
    ......
}

PS:文章最后附录了完整的java.lang.Enum，有兴趣的可以看一看

我们先来定义一个简单的enum（如下）：

public enum Color{
    RED,BLUE,BLACK,YELLOW
}

ps：别去追究它为什么这么写，因为这是语法。
它也等价于:

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

总结：
1.用enum关键字来定义枚举类。
2.显示的列出枚举值（请在第一行就这么做，并大写），用逗号隔开。

本质上：Color枚举类字节码代码（大致）：

//注意几个地方：1.类的修饰为final；2.RED的类型，和修饰词；
public final class enums.Color extends java.lang.Enum<enums.Color> {
    public static final enums.Color RED;
    public static final enums.Color BLUE;
    public static final enums.Color BLACK;
    public static final enums.Color YELLOW;
    .........
}

由此可以得出枚举的一些本质：

(1)使用enum定义的枚举类，本质上是class类(我还是想用［有些特殊］来形容)，只是它默认直接继承了java.lang.Enum类。［请把它当作class看待］

(2)枚举值（RED，BLUE…..）本质上是枚举Color对象，并且他们是final修饰的静态常量。这些值我们一般使用构造器的方式去初始化（后面会提到）。

(3)枚举类的构造器只能使用private访问控制符，哪怕是隐藏的构造器，它的访问控制符也是private。
PS：这点也很好理解，当需要我们使用构造器时。
无非是这么两种情况：
1.需要创建一个实例；然而枚举里面的枚举值是静态的，我们不需要通过创建实例来得到它。
2.需要初始化属性；我想如果你用枚举，就一定不会去这么做。因为那是常量并且是final。

(4)使用enum定义非抽象的枚举类默认会使用final修饰。但是（如）：当枚举内有抽象方法时，该枚举类即为非抽象枚举类，不会被final修饰，这意味着可以被继承。（在后面还会提到，如果无法理解请先跳过）。

实际使用：

1.如果需要使用枚举类的某个实例，可以使用“枚举类.某个实例”的形式，例如Color.RED。注意，这里只是获取实例。实际使用中，获取实例只是第一步，后续还有一个取值的过程（后面给大家介绍）。

public class Test {
    public static void querColor(Color c) {
        switch (c) {
        case RED:
            System.out.println("我选了红色");
            break;
        case BLUE:
            System.out.println("我选了蓝色");
            break;
        case BLACK:
            System.out.println("我换了黑色");
            break;
        case YELLOW:
            System.out.println("我选了黄色");
            break;
        }
    }
    public static void main(String[] args) {
        queryColor(Color.RED); //枚举取实例
    }
}

JDK1.5增加枚举后对switch也进行了扩展，switch的条件表达式可以使用枚举类型。当switch条件表达式使用枚举类型时，case中的值可以直接使用枚举值名字。

2.我们往往在使用枚举时就希望枚举对象（枚举值）是不可变的。即枚举类的所有Field都应该用final修饰（它本身也是这么做的）。在这里我们一般使用构造器给这些属性初始化值。（或者在定义Field时指定默认值，或者在初始化块中指定初始值，但这两种情况不推荐）。
在实际开发过程中，我们根据业务需求，在定义枚举类时数据结构都会比Color复杂。如：UserTypeEnum

public enum UserTypeEnum {
    ADMINISTRATOR(0, "管理员"), SHOP(2, "门店"), WAITER(1, "小二"), SELLER(3, "销售");  

    private Integer code; 
    private String  desc;

    private UserTypeEnum(Integer code, String desc){
        this.setCode(code);
        this.setDesc(desc);
    }

    public String getDesc() {
        return desc;
    }
    public Integer getCode() {
        return code;
    }
    //**不应该存在set方法。**
}

上面程序中 ADMINISTRATOR(0, “管理员”), SHOP(2, “门店”), WAITER(1, “小二”), SELLER(3, “销售”)，等同于如下代码：

//这点非常关键
private static final UserTypeEnum ADMINISTRATOR=new UserTypeEnum(0, "管理员");
private static final UserTypeEnum SHOP=new UserTypeEnum(2, "门店"),;
private static final UserTypeEnum WAITER=new UserTypeEnum(1, "小二");
private static final UserTypeEnum SELLER=new UserTypeEnum(3, "销售");

到了这里你需要好好理解一下，既然等价于new UserTypeEnum(2, "门店") ...我想你应该也能明白为什么需要写显示的带参构造器。

PS:如果枚举值括号内没有值(理解为调用无参构造)，是可以省略的。这也很好的解释了文章开头：

ADMINISTRATOR  等价于  ADMINISTRATOR（）

取值的过程：

UserTypeEnum.SHOP.getDesc()  //即能得到"门店"
UserTypeEnum.SHOP.getCode()  //即能得到2

这个时候你就会发现，他真的就是一个［普通］的class。是不是很简单！

3.枚举类也可以实现一个或多个接口。与普通类实现一个或多个接口完全一样，枚举类实现一个或多个接口时，也需要实现该接口所包含的方法。

public interface PrintColor {
    void print();
}

public enum Color implements PrintColor{
    RED, BLUE, BLACK, YELLOW;
    @Override
    public void print() {
        System.out.println("print......");
    }

}

如果由枚举类来实现接口里的方法，则每个枚举类（枚举值）对象在调用该方法时，都有相同的行为方式（因为方法体完全一样）。如果需要每个枚举对象在调用该方法时，呈现出不同的行为方式，则可以让每个枚举对象分别来实现该方法。

public interface PrintColor {
    void print();
}

public enum Color implements PrintColor {
    RED {
        @Override
        public void print() {
            System.out.println("画红色！");
        }
    },
    BLUE {
        @Override
        public void print() {
            System.out.println("画蓝色！");
        }
    },
    BLACK {
        @Override
        public void print() {
            System.out.println("画黑色！");
        }
    },
    YELLOW {
        @Override
        public void print() {
            System.out.println("画黄色！");
        }
    };
}

RED、BLUE、BLACK和YELLOW实际上是Color匿名子类的实例，而不是Color类的实例。我的理解是这个时候Color变成了抽象类。

注意：并不是所有的枚举类都使用了final修饰。非抽象的枚举类才默认使用final修饰。对于一个抽象的枚举类而言（只要它包含了抽象方法，它就是抽象枚举类），系统会默认使用abstract修饰，而不是使用final修饰。

每个枚举对象提供不同的实现方式，从而让不同的枚举对象调用该方法时，具有不同的行为方式。

4.如果不使用接口，而是直接在枚举类中定义一个抽象方法，然后再让每个枚举对象提供不同的实现方式。

public enum Color {
    RED {
        @Override
        public void print() {
            System.out.println("画红色！");
        }
    },
    BLUE {
        @Override
        public void print() {
            System.out.println("画蓝色！");
        }
    },
    BLACK {
        @Override
        public void print() {
            System.out.println("画黑色！");
        }
    },
    YELLOW {
        @Override
        public void print() {
            System.out.println("画黄色！");
        }
    };
    abstract void print();
}

Color是一个包含抽象方法的枚举类，但是“public enum Color”没有使用abstract修饰，这是因为编译器（javac）会在编译生成.class时,自动添加abstract。同时，因为Color包含一个抽象方法，所以它的所有枚举对象都必须实现抽象方法，否则编译器会报错。

另外在实际使用中，我们也会用枚举来做其他事情：
比如说，
public void modifyListing(List<Long> itemIds， Long status)
public void modifyListing(List<Long> itemIds， MallItemStatusEnum status)
这两个方法是同一个方法，只是参数一个用了Long类型的，另一个用了MallItemStatusEnum枚举类型的。
而区别好处：
前者，只要随便传一个值都行。事实上如果这么做，你肯定会在方法里面做一个校验，确保这个值不会出现问题。
而后者不需要，最多进行一个判断status是否为空操作。

附录：java.lang.Enum

/*
 * %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() { }
}