[不懂就问] Java .lang.Enum 源码的两个疑问

最近看书刚看懂 java 泛型的自限定，合计去找找源码的应用，发现 enum 这样用的。下面就是一个枚举类的使用：

public enum WeekDay {
    Mon("Monday"), Tue("Tuesday"), Wed("Wednesday"), Thu("Thursday"), Fri( "Friday"), Sat("Saturday"), Sun("Sunday");
    private final String day;
    private WeekDay(String day) {
        this.day = day;
    }
    public static void printDay(int i){
        switch(i){
            case 1: System.out.println(WeekDay.Mon); break;
            case 2: System.out.println(WeekDay.Tue);break;
            case 3: System.out.println(WeekDay.Wed);break;
            case 4: System.out.println(WeekDay.Thu);break;
            case 5: System.out.println(WeekDay.Fri);break;
            case 6: System.out.println(WeekDay.Sat);break;
            case 7: System.out.println(WeekDay.Sun);break;
            default:System.out.println("wrong number!");
        }
    }
    public String getDay() {
        return day;
    }
    public static void main(String[] args) {
        WeekDay a = WeekDay.Mon;
    }
}

通过 javap 命令才能看出来新类 WeekDay 实际继承了 java.lang.Enum，public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { }。截取部分汇编来看，发现确实继承了 java.lang.Enum，看它的成员和方法的类型，也确实做到了自限定：

public final class WeekDay extends java.lang.Enum<WeekDay> {
  public static final WeekDay Mon;

  public static final WeekDay Tue;

  public static final WeekDay Wed;

  public static final WeekDay Thu;

  public static final WeekDay Fri;

  public static final WeekDay Sat;

  public static final WeekDay Sun;

  public static WeekDay[] values();
  public static WeekDay valueOf(java.lang.String);

于是看了看 Enum 的源码，有了几个疑问： 1.从汇编看来，好像继承来了两个方法，public static WeekDay[] values();，public static WeekDay valueOf(java.lang.String);，但是在源码里找不到这两个静态方法的定义。只能在注释里找到：

     * <p>Note that for a particular enum type {@code T}, the
     * implicitly declared {@code public static T valueOf(String)}
     * method on that enum may be used instead of this method to map
     * from a name to the corresponding enum constant.  All the
     * constants of an enum type can be obtained by calling the
     * implicit {@code public static T[] values()} method of that
     * type.
     //只能找到注释里说了，说这两个方法是隐式声明的，什么鬼？
     //注释下面是这个方法
    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);
    }

2.getDeclaringClass 方法为啥这么实现？

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

compareTo 是 Comparable 接口里的方法，这里 Enum 源码帮忙实现了。compareTo 的实现比较清晰，首先看是不是同一种 enum type，如果是，再比较两个 enum constant。但是用到了 getDeclaringClass 方法，这个方法有点奇怪哎，首先我觉得 self.getClass() != other.getClass()这样就足够判断是不是同一种 enum type 了呀？

然后，再看 getDeclaringClass 方法的逻辑，Class<?> clazz = getClass();调用自己的成员方法获得自己的 Class 对象，然后Class<?> zuper = clazz.getSuperclass();获得自己父类的 Class 对象，自己的父类不是肯定是 Enum 吗？那最后return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;这里三目表达式不是肯定判断为真吗

xuanyu66

2019-10-13 15:16:33 +08:00

@amiwrong123 别纠结这些定义吧。其实静态内部类也可以是没名字的啊。
```
public enum MyEnum {

A {
void doSomething() { }
},

B {
void doSomethingElse() { }
};

static class SS {

}

public void countDown(){
new Thread(){
@Override
public void run() {

}
}.start();
}

public static void main(String[] args) {
System.out.println(MyEnum.A.getDeclaringClass());
System.out.println(MyEnum.A.getClass());
System.out.println(MyEnum.A.getClass().getSuperclass());
SS s = new SS();
System.out.println(s.getClass());
System.out.println(s.getClass().getSuperclass());
System.out.println(Enum.valueOf(MyEnum.class,"A"));
}
}
```
你看这段代码运行后会生成 MyEnum$3.class，就是你指的所谓的”匿名内部类“。你会发现底层实现不区分这些区别。没有指定名字的类就是从 1 开始编排，如果你是 static 就不会传外部类的引用，不是 static 就传引用。
class org.bupt.pms.consistence.MyEnum$3 extends java.lang.Thread {
final org.bupt.pms.consistence.MyEnum this$0;

org.bupt.pms.consistence.MyEnum$3(org.bupt.pms.consistence.MyEnum); //看这里
Code:
0: aload_0
1: aload_1
2: putfield #1 // Field this$0:Lorg/bupt/pms/consistence/MyEnum;
5: aload_0
6: invokespecial #2 // Method java/lang/Thread."<init>":()V
9: return

public void run();
Code:
0: return
}