java源码学习（三）Enum

Enum

Enum类是java.lang包中一个类，他是Java语言中所有枚举类型的公共基类。

一、定义

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

1.抽象类

首先，抽象类不能被实例化，所以我们在java程序中不能使用new关键字来声明一个Enum，如果想要定义可以使用这样的语法：

enum enumName{
    value1,value2
    method1(){}
    method2(){}
}

其次，看到抽象类，第一印象是肯定有类继承他。至少我们应该是可以继承他的，所以：

public class testEnum extends Enum{
}
public class testEnum extends Enum<Enum<E>>{
}
public class testEnum<E> extends Enum<Enum<E>>{
}

尝试了以上三种方式之后，得出以下结论：Enum类无法被继承。

为什么一个抽象类不让继承？enum定义的枚举是怎么来的？难道不是对Enum的一种继承吗？带着这些疑问我们来反编译以下代码：

enum Color {RED, BLUE, GREEN}

编译器将会把他转成如下内容：

public final class Color extends Enum<Color> {
  public static final Color[] values() { return (Color[])$VALUES.clone(); }
  public static Color valueOf(String name) { ... }

  private Color(String s, int i) { super(s, i); }

  public static final Color RED;
  public static final Color BLUE;
  public static final Color GREEN;

  private static final Color $VALUES[];

  static {
    RED = new Color("RED", 0);
    BLUE = new Color("BLUE", 1);
    GREEN = new Color("GREEN", 2);
    $VALUES = (new Color[] { RED, BLUE, GREEN });
  }
}

短短的一行代码，被编译器处理过之后竟然变得这么多，看来，enmu关键字是java提供给我们的一个语法糖啊。。。从反编译之后的代码中，我们发现，编译器不让我们继承Enum，但是当我们使用enum关键字定义一个枚举的时候，他会帮我们在编译后默认继承java.lang.Enum类，而不像其他的类一样默认继承Object类。且采用enum声明后，该类会被编译器加上final声明，故该类是无法继承的。 PS：由于JVM类初始化是线程安全的，所以可以采用枚举类实现一个线程安全的单例模式。

2.实现Comparable和Serializable接口

Enum实现了Serializable接口，可以序列化。 Enum实现了Comparable接口，可以进行比较，默认情况下，只有同类型的enum才进行比较（原因见后文），要实现不同类型的enum之间的比较，只能复写compareTo方法。

3.泛型：<E extends Enum<E>>

怎么理解<E extends Enum<E>>?

首先，这样写只是为了让Java的API更有弹性，他主要是限定形态参数实例化的对象，故要求只能是Enum，这样才能对 compareTo 之类的方法所传入的参数进行形态检查。所以，我们完全可以不必去关心他为什么这么设计。

这里倒是可以关注一下泛型中extends的用法，以及K V O T E ？ object这几个符号之间的区别。

好啦，我们回到这个令人实在是无法理解的<E extends Enum>

首先我们先来“翻译”一下这个Enum<E extends Enum>到底什么意思，然后再来解释为什么Java要这么用。 我们先看一个比较常见的泛型：List。这个泛型的意思是，List中存的都是String类型，告诉编译器要接受String类型，并且从List中取出内容的时候也自动帮我们转成String类型。 所以Enum<E extends Enum>可以暂时理解为Enum里面的内容都是E extends Enum类型。 这里的E我们就理解为枚举，extends表示上界，比如： List<? extends Object>，List中的内容可以是Object或者扩展自Object的类。这就是extends的含义。 所以，E extends Enum表示为一个继承了Enum类型的枚举类型。 那么，Enum<E extends Enum>就不难理解了，就是一个Enum只接受一个Enum或者他的子类作为参数。相当于把一个子类或者自己当成参数，传入到自身，引起一些特别的语法效果。

二、属性

在Enum中，有两个成员变量，一个是名字(name)，一个是序号(ordinal)。 序号是一个枚举常量，表示在枚举中的位置，从0开始，依次递增。

private final String name；
public final String name() {
    return name;
}
private final int ordinal;
public final int ordinal() {
    return ordinal;
}

三、方法

1. 构造方法

前面我们说过，Enum是一个抽象类，不能被实例化，但是他也有构造函数，从前面我们反编译出来的代码中，我们也发现了Enum的构造函数，在Enum中只有一个保护类型的构造函数：

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

文章开头反编译的代码中private Color(String s, int i) { super(s, i); }中的super(s, i);就是调用Enum中的这个保护类型的构造函数来初始化name和ordinal。

2. 其它方法

	public String toString() {
		return name;
	}

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

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

    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;
    }

    public final Class<E> getDeclaringClass() {
        Class clazz = getClass();
        Class zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? clazz : 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);
    }

四、参考资料

http://www.hollischuang.com/archives/92