一般常量的定义方式

来自 Effective Java Edition 3


// The int enum pattern - severely deficient!
public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;
public static final int ORANGE_NAVEL = 0;
public static final int ORANGE_TEMPLE = 1;
public static final int ORANGE_BLOOD = 2;

缺点

1、类型不安全:当传递给需要 ORANGE_xx 的方法时不会检查

2、缺乏表现力:int 直接输出显示为数字,没有意义。

3、编译时常量:常量被编译到客户端时,若常量发生改变,则客户端会报错

4、硬编码易出错:String 类型常量若书写错误,编译时逃脱检验,运行时报错

5、功能有限:没有有效的方法迭代常量组,也没有办法获得常量组的大小

语法定义

从 JDK1.5 开始,枚举类解决了上述的所有缺点。创建枚举类型要使用 enum 关键字,隐含了所创建的类型都是 java.lang.Enum 类的子类(java.lang.Enum 是一个抽象类)。枚举类型符合通用模式 abstract Class Enum<E extends Enum>,而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中(ordinal 从 0 开始)。在这里,每个值的名称都被转换成一个字符串,并且序数设置表示了此设置被创建的顺序。


public enum EnumTest {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

这段代码实际上调用了7Enum(String name, int ordinal)new Enum<EnumTest>("MON",0);
new Enum<EnumTest>("TUE",1);
new Enum<EnumTest>("WED",2);
    ... ...
遍历、switch 等常用操作

对enum进行遍历和switch的操作示例代码:
public class Test {
    public static void main(String[] args) {
        for (EnumTest e : EnumTest.values()) {
            System.out.println(e.toString());
        }

        System.out.println("----------------我是分隔线------------------");

        EnumTest test = EnumTest.TUE;
        switch (test) {
        case MON:
            System.out.println("今天是星期一");
            break;
        case TUE:
            System.out.println("今天是星期二");
            break;
        // ... ...
        default:
            System.out.println(test);
            break;
        }
    }
}

  • 输出结果:
MON
TUE
WED
THU
FRI
SAT
SUN
----------------我是分隔线------------------
今天是星期二

Enum 实例分析

由于枚举类都继承了 Enum 类,所以类中声明的枚举可以调用许多父类已有的方法

Enum.class

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

        private final String name;
        private final int ordinal;

        public final String name() {
            return name;
        }
        public final int ordinal() {
            return ordinal;
        }
        protected Enum(String name, int ordinal) {
            this.name = name;
            this.ordinal = ordinal;
        }
        public String toString() {
            return name;
        }
        public final boolean equals(Object other) {
            return this==other;
        }
        public final int hashCode() {
            return super.hashCode();
        }
        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;
        }
        @SuppressWarnings("unchecked")
        public final Class<E> getDeclaringClass() {
            Class<?> clazz = getClass();
            Class<?> zuper = clazz.getSuperclass();
            return (zuper == 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);
        }
        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");
        }

常用方法简要说明

int compareTo(E o) 
          比较此枚举与指定对象o的顺序。

Class<E> getDeclaringClass() 
          返回与此枚举常量的枚举类型相对应的 Class 对象。

String name() 
          返回此枚举常量的名称,在其枚举声明中对其进行声明。

int ordinal() 
          返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。

String toString()
           返回枚举常量的名称,它包含在声明中。

static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) 
          返回带指定名称的指定枚举类型的枚举常量。

boolean equals(Object other)
        比较两个枚举常量是否相等

测试 Demo

EnumTest

public enum EnumTest {

    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6) {
        @Override
        public boolean isRest() {
            return true;
        }
    },
    SUN(0) {
        @Override
        public boolean isRest() {
            return true;
        }
    };

    private final int value;

    private EnumTest(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public boolean isRest() {
        return false;
    }

}

TestDemo1

public class TestDemo1 {
    public static void main(String[] args) {
        EnumTest test = EnumTest.TUE;

        // compareTo(E o),self.ordinal - other.ordinal
        switch (test.compareTo(EnumTest.MON)) {
        case -1:
            System.out.println("TUE 在 MON 之前");
            break;
        case 1:
            System.out.println("TUE 在 MON 之后");
            break;
        default:
            System.out.println("TUE 与 MON 在同一位置");
            break;
        }

        // getDeclaringClass()
        System.out.println("getDeclaringClass(): " + test.getDeclaringClass().getName());

        // name() 和  toString()
        System.out.println("name(): " + test.name());
        System.out.println("toString(): " + test.toString());

        // ordinal(), 返回值是从 0 开始
        System.out.println("ordinal(): " + test.ordinal());

        // 将常量名称转换为常量本身
        System.out.println("valueOf:" + Enum.valueOf(EnumTest.class, "TUE").getValue());

        // equals(Object o)
        System.out.println(test.equals(EnumTest.TUE));
    }
}

  • 输出结果:
TUE 在 MON 之后
getDeclaringClass(): com.livejq.enums.EnumTest
name(): TUE
toString(): TUE
ordinal(): 1
valueOf:2
true

TestDemo2


public class TestDemo2 {
    public static void main(String[] args) {
        // EnumSet的使用
        EnumSet<EnumTest> weekSet = EnumSet.allOf(EnumTest.class);
        for (EnumTest day : weekSet) {
            System.out.println(day);
        }

        // EnumMap的使用
        EnumMap<EnumTest, String> weekMap = new EnumMap(EnumTest.class);
        weekMap.put(EnumTest.MON, "星期一");
        weekMap.put(EnumTest.TUE, "星期二");
        // ... ...
        for (Iterator<Entry<EnumTest, String>> iter = weekMap.entrySet().iterator(); iter.hasNext();) {
            Entry<EnumTest, String> entry = iter.next();
            System.out.println(entry.getKey().name() + ":" + entry.getValue());
        }
    }
}

原理分析

反汇编

根据class字节码文件,反解析出当前类对应的code区(汇编指令)、本地变量表、异常表和代码行偏移量映射表、常量池等等信息。

EnumTest 使用反汇编命令 javap EnumTest.class 得到如下:


public class EnumTest extends java.lang.Enum<EnumTest> {
  public static final EnumTest MON;
  public static final EnumTest TUE;
  public static final EnumTest WED;
  public static final EnumTest THU;
  public static final EnumTest FRI;
  public static final EnumTest SAT;
  public static final EnumTest SUN;
  public static EnumTest[] values();
  public static EnumTest valueOf(java.lang.String);
  public int getValue();
  public boolean isRest();
  EnumTest(java.lang.String, int, int, EnumTest$1);
  static {};
}

所以,实际上 enum 就是一个 class,只不过 java 编译器帮我们做了语法的解析和编译而已。

反编译

使用 jad 反编译工具可以查看详细的编译后代码,
下载后放到想反编译的类下,运行:

jad -s java EnumTest.java

具体命令看README.txt,-s为suffix,定义后缀名(默认生成.jad文件)

enum 的语法结构尽管和 class 的语法不一样,但是经过编译器编译之后产生的是一个 class 文件。该 class 文件经过反编译可以看到实际上是生成了一个类,该类继承了java.lang.Enum。


public class EnumTest extends Enum
{

    public static EnumTest[] values()
    {
        return (EnumTest[])$VALUES.clone();
    }

    public static EnumTest valueOf(String s)
    {
        return (EnumTest)Enum.valueOf(EnumTest, s);
    }

    private EnumTest(String s, int i, int j)
    {
        super(s, i);
        value = j;
    }

    public int getValue()
    {
        return value;
    }

    public boolean isRest()
    {
        return false;
    }


    public static final EnumTest MON;
    public static final EnumTest TUE;
    public static final EnumTest WED;
    public static final EnumTest THU;
    public static final EnumTest FRI;
    public static final EnumTest SAT;
    public static final EnumTest SUN;
    private int value;
    private static final EnumTest $VALUES[];

    static 
    {
        MON = new EnumTest("MON", 0, 1);
        TUE = new EnumTest("TUE", 1, 2);
        WED = new EnumTest("WED", 2, 3);
        THU = new EnumTest("THU", 3, 4);
        FRI = new EnumTest("FRI", 4, 5);
        SAT = new EnumTest("SAT", 5, 6) {

            public boolean isRest()
            {
                return true;
            }

        }
;
        SUN = new EnumTest("SUN", 6, 0) {

            public boolean isRest()
            {
                return true;
            }

        }
;
        $VALUES = (new EnumTest[] {
            MON, TUE, WED, THU, FRI, SAT, SUN
        });
    }
}
  1. 由于其中的枚举常量声明为 final 类,并且构造方法为 private ,所以客户端不能够实例化或继承。
  2. 由于父类实现的序列化接口中实现了 readObject 方法为不可用,所以枚举常量不能够被反序列化。
  3. 枚举类提供了编译时的安全。若声明一个枚举类,则其中枚举类型必定相同,尝试传递错误类型的值将导致编译时错误。
  4. 可以在枚举类型中添加或重新排序常量,而无需重新编译其客户端,因为导出常量的属性在枚举类型与其客户端之间提供了一层隔离。
  5. 常量值不会编译到客户端,因为它们位于 int 枚举模式中,可以通过调用其 toString 方法将枚举转换为可打
    印的字符串。

参考文章:

java enum(枚举)使用详解

相关文章:

  1. 浅谈在Java开发中的枚举的作用和用法
  2. 反编译工具分析枚举的原理
  • Java 继承调用父类构造函数

    实例分析public class ParentTest { public ParentTest() { System.ou...

    Java 继承调用父类构造函数
  • IO流

    Java IO体系结构IO实际上分为阻塞型IO(Blocking IO)和非阻塞型IO(Non-Blocking IO 简称NIO) ...

    IO流
  • Try-With-Resources声明

    try-with-resources语句try-with-resources语句是一种声明了一种或多种资源的try语句。资源是指在程序...

    Try-With-Resources声明