[不懂就问] 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;这里三目表达式不是肯定判断为真吗