Class最後一部分原始碼，這一部分大都是private方法、屬性、類，都是Class本身各種方法的實現細節，涉及到了很多Class的實現原理，較為深奧，網上能找到的資料也比較少，目前只懂皮毛，僅供參考，所以，我這一部分說的可能是不正確的，需要抱著懷疑的態度看待！咳，就這樣，閃人。

//快取反射的資料資訊
private volatile transient SoftReference<ReflectionData<T>> reflectionData;
//由JVM自動增加，表示虛擬機器內，該類被重新定義的次數，JVM TI可以動態更新類定義
//關於類的動態定義這一點，可以參考：
 

//  http://blog.csdn.net/raintungli/article/details/51655608
private volatile transient int classRedefinedCount = 0;
    private ReflectionData<T> reflectionData() {
        //獲取快取中的反射資料，如果沒啟用快取，或者沒資料，則呼叫下面方法，新建反射快取資料
    }
private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
                                                int
 
 classRedefinedCount) {
       ......
    }
/**
 * 檢視該類是否是泛型，雖然jdk上面說的是簽名的handler(雖然我也不太明白這簽名是什麼)，
 * 但是我查到，很多地方，包括Class原始碼上面判斷泛型相關，都有類似這句程式碼：
 *  if (getGenericSignature() != null)
 * 詳見：getGenericInterfaces()方法以及類似方法
 */
//
private native String getGenericSignature();
/**
 * 該類的型別倉庫，其主要作用是操作及快取該類的型別資訊以及父類資訊，比如其內就有泛型
 * 工廠物件，和父類物件型別資訊及所實現的父類介面資訊
 */
 

private transient ClassRepository genericInfo;

/**
 * GenericsFactory：泛型工廠，用來生產及操作各種型別物件（Java型別詳見：）
 * http://blog.csdn.net/a327369238/article/details/52621043
 */
private GenericsFactory getFactory() {
        return CoreReflectionFactory.make(this, ClassScope.make(this));
    }
    private ClassRepository getGenericInfo() {
        if (genericInfo == null) {
            genericInfo = ClassRepository.make(getGenericSignature(),
                                               getFactory());
        }
        return genericInfo; 
    }
    //獲取該類的註解，本地實現，詳見getAnnotation()
    native byte[] getRawAnnotations();
    //獲取常量池
    native ConstantPool getConstantPool();
    //獲取所有欄位資訊，可根據引數獲取相應訪問許可權型別欄位————————方法1
    private Field[] privateGetDeclaredFields(boolean publicOnly) {
       //只獲取該類宣告的欄位（所有許可權型別的），其父類、父介面中宣告的並沒有
    }
    //類似上面方法，但是返回的是public型別欄位，且包括父類、父介面中宣告定義的
    //要學會看方法名字，根據英文意思大概能知道方法意義——————————方法2
    private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces){
    //有反射的快取資料，則直接獲取後返回
       //若沒有，則通過上面方法獲取（引數置為true）
       //還要加上其父類以及父介面中宣告的公共欄位
    }
    private static void addAll(Collection<Field> c, Field[] o) {
        for (int i = 0; i < o.length; i++) {
            c.add(o[i]);
        }
    }
    //類似方法1
    private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
       ......
    }
    //類似方法1
    private Method[] privateGetDeclaredMethods(boolean publicOnly) {
        ......
    }
    //方法陣列類
    static class MethodArray {
        private Method[] methods;
        private int length;

        MethodArray() {
            methods = new Method[20];
            length = 0;
        }

        void add(Method m) {
            if (length == methods.length) {
                methods = Arrays.copyOf(methods, 2 * methods.length);
            }
            methods[length++] = m;
        }

        void addAll(Method[] ma) {
            for (int i = 0; i < ma.length; i++) {
                add(ma[i]);
            }
        }

        void addAll(MethodArray ma) {
            for (int i = 0; i < ma.length(); i++) {
                add(ma.get(i));
            }
        }

        void addIfNotPresent(Method newMethod) {
            for (int i = 0; i < length; i++) {
                Method m = methods[i];
                if (m == newMethod || (m != null && m.equals(newMethod))) {
                    return;
                }
            }
            add(newMethod);
        }

        void addAllIfNotPresent(MethodArray newMethods) {
           ......
        }

        int length() {
            return length;
        }

        Method get(int i) {
            return methods[i];
        }

        void removeByNameAndSignature(Method toRemove) {
            ......
        }

        void compactAndTrim() {
           ......
        }

        Method[] getArray() {
            return methods;
        }
    }
    //類似方法2
    private Method[] privateGetPublicMethods() {
        ......
    }
    //根據欄位名稱獲取fields中欄位資訊————————方法3
    private static Field searchFields(Field[] fields, String name) {
    }
    //只獲取public欄位————————方法4
    private Field getField0(String name) throws NoSuchFieldException {
       Field res;
        // 首先，在本類公共欄位中搜索獲取同名欄位
        if ((res = searchFields(privateGetDeclaredFields(true), name)) != null) {
            return res;
        }
        // 若無，則搜尋父介面同名欄位，遞迴呼叫
        Class<?>[] interfaces = getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            Class<?> c = interfaces[i];
            if ((res = c.getField0(name)) != null) {
                return res;
            }
        }
        // 若仍無，判斷該類為非介面型別，獲取父類同名欄位，遞迴呼叫
        if (!isInterface()) {
            Class<?> c = getSuperclass();
            if (c != null) {
                if ((res = c.getField0(name)) != null) {
                    return res;
                }
            }
        }
        //都無，則返回空
        return null;
    }
    //類似方法3
    private static Method searchMethods(Method[] methods,
                                        String name,
                                        Class<?>[] parameterTypes)
    {
        ......
    }
    //類似方法4
    private Method getMethod0(String name, Class<?>[] parameterTypes) {
      ......
    }
    //類似方法4
    private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
                                        int which) throws NoSuchMethodException
    {
    }
    //輔助，判斷陣列是否相等
    private static boolean arrayContentsEq(Object[] a1, Object[] a2) {

    }
    //複製欄位陣列資訊
    private static Field[] copyFields(Field[] arg) {
        Field[] out = new Field[arg.length];
        ReflectionFactory fact = getReflectionFactory();
        for (int i = 0; i < arg.length; i++) {
            out[i] = fact.copyField(arg[i]);
        }
        return out;
    }
    //複製方法陣列資訊
    private static Method[] copyMethods(Method[] arg) {
        Method[] out = new Method[arg.length];
        ReflectionFactory fact = getReflectionFactory();
        for (int i = 0; i < arg.length; i++) {
            out[i] = fact.copyMethod(arg[i]);
        }
        return out;
    }
    //複製構造器陣列資訊
    private static <U> Constructor<U>[] copyConstructors(Constructor<U>[] arg) {
        Constructor<U>[] out = arg.clone();
        ReflectionFactory fact = getReflectionFactory();
        for (int i = 0; i < out.length; i++) {
            out[i] = fact.copyConstructor(out[i]);
        }
        return out;
    }
    //以下四個，為獲取本類所有宣告的欄位/方法/構造器/類
    private native Field[]       getDeclaredFields0(boolean publicOnly);
    private native Method[]      getDeclaredMethods0(boolean publicOnly);
    private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
    private native Class<?>[]   getDeclaredClasses0();
    //輸出型別陣列各個名稱
    private static String        argumentTypesToString(Class<?>[] argTypes) {
       .......
    }
    private static final long serialVersionUID = 3206093459760846163L;
    //ObjectStreamField：序列化的物件中成員屬性的元資料資訊
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];
    //獲取該類的斷言狀態，類的斷言狀態可通過類的ClassLoader設定
    public boolean desiredAssertionStatus() {
       ......
    }
    //上面方法的本地實現
    private static native boolean desiredAssertionStatus0(Class<?> clazz);
    //判斷是否是列舉型別
    public boolean isEnum() {
        return (this.getModifiers() & ENUM) != 0 &&
        this.getSuperclass() == java.lang.Enum.class;
    }
    private static ReflectionFactory getReflectionFactory() {
    }
    //反射工廠，可以通過可個工廠對類的元資料進行操作，比如新建一個構造器、方法等
    private static ReflectionFactory reflectionFactory;
    //系統屬性是否初始化
    private static boolean initted = false;
    //判斷系統屬性是否已經初始化，若已經初始化，直接返回，否則初始化
    private static void checkInitted() {
        if (initted) return;
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    ......
                }
    }
    //如果，此類為列舉類，返回其中的列舉值，否則返回空
    public T[] getEnumConstants() {
        T[] values = getEnumConstantsShared();
        return (values != null) ? values.clone() : null;
    }
    //如果此類為列舉類，返回其中的列舉值，否則返回空
    T[] getEnumConstantsShared() {
         ......
    }
    //列舉值
    private volatile transient T[] enumConstants = null;
    //將列舉轉化為map<String, T> String是每個列舉的name屬性
    Map<String, T> enumConstantDirectory() {
       if (enumConstantDirectory == null) {//若快取中為空
            T[] universe = getEnumConstantsShared();//獲取所有列舉值
            if (universe == null)//為空則丟擲異常
                throw new IllegalArgumentException(
                    getName() + " is not an enum type");
            Map<String, T> m = new HashMap<>(2 * universe.length);
            for (T constant : universe)//遍歷儲存
                m.put(((Enum<?>)constant).name(), constant);
            enumConstantDirectory = m;
        }
        return enumConstantDirectory;
    }
    private volatile transient Map<String, T> enumConstantDirectory = null;
    //強制轉換，如例項為null或不是例項物件，且強制轉換不成功，丟擲異常
    public T cast(Object obj) {
        if (obj != null && !isInstance(obj))
            throw new ClassCastException(cannotCastMsg(obj));
        return (T) obj;//只是簡單的進行強制轉換
    }
    //無法強轉的報錯資訊
    private String cannotCastMsg(Object obj) {
        return "Cannot cast " + obj.getClass().getName() + " to " + getName();
    }
    //將呼叫這個方法的class物件轉換成由clazz引數所表示的class物件的某個子類
    //可參考：http://blog.csdn.net/csywwx2008/article/details/17641405
    public <U> Class<? extends U> asSubclass(Class<U> clazz) {
        if (clazz.isAssignableFrom(this))
            return (Class<? extends U>) this;
        else
            throw new ClassCastException(this.toString());
    }
    //獲得引數對應的註解物件資訊
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
        if (annotationClass == null)
            throw new NullPointerException();

        initAnnotationsIfNecessary();
        return (A) annotations.get(annotationClass);
    }
    //判斷該註解型別是否是在該類上（有該註解）
    public boolean isAnnotationPresent(
        Class<? extends Annotation> annotationClass) {
        if (annotationClass == null)
            throw new NullPointerException();

        return getAnnotation(annotationClass) != null;
    }
    //獲取該類上所有註解（包括繼承），無，則返回長度為零的註解陣列
    public Annotation[] getAnnotations() {
        initAnnotationsIfNecessary();
        return AnnotationParser.toArray(annotations);
    }
    //獲取該類上所有的宣告的註解（不包括繼承的），無，則返回長度為零的註解陣列
    public Annotation[] getDeclaredAnnotations()  {
        initAnnotationsIfNecessary();
        return AnnotationParser.toArray(declaredAnnotations);
    }
    private transient Map<Class<? extends Annotation>, Annotation> annotations;
    private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
   //類似classRedefinedCount，最後一次註解被定義的個數
    private  transient int lastAnnotationsRedefinedCount = 0;
    //在類被反射重新定義的時候，清除快取的註解資訊
    private void clearAnnotationCachesOnClassRedefinition() {
        if (lastAnnotationsRedefinedCount != classRedefinedCount) {//二者不相等，說明類有被重新定義
            annotations = declaredAnnotations = null;//清空資訊
            lastAnnotationsRedefinedCount = classRedefinedCount;
        }
    }
    //初始化類的註解（快取資訊：annotations和declaredAnnotations）
    private synchronized void initAnnotationsIfNecessary() {
        ......
    }
    //註解型別資訊快取
    @SuppressWarnings("UnusedDeclaration")
    private volatile transient AnnotationType annotationType;

    boolean casAnnotationType(AnnotationType oldType, AnnotationType newType) {
        return Atomic.casAnnotationType(this, oldType, newType);
    }

    AnnotationType getAnnotationType() {
        return annotationType;
    }
    transient ClassValue.ClassValueMap classValueMap;
}

1.關於反射工廠ReflectionFactory，是一個很破壞安全的類：

public class Test {
    private Test(){
        System.out.println("test");
    }
    public void say(){
        System.out.println("hello world");
    }
}//按理說，Test這個類只有私有構造器，外部類不能例項化，也就不能在外呼叫say方法
public class Main{
    private static final ReflectionFactory reflectionFactory = (ReflectionFactory) AccessController
            .doPrivileged(new ReflectionFactory.GetReflectionFactoryAction());
    public static void main(String[] args) throws Exception{
        Constructor<Test> constr = reflectionFactory.newConstructorForSerialization(Test.class, Object.class.getConstructor(new Class[0]));
        Test test = constr.newInstance(new Object[0]);
        test.say();
    }
}
/**
 * 然而事實，卻是可以通過ReflectionFactory這個反射工廠新建一個Test的構造器，而後
 * 通過newInstance獲取其例項，進而訪問其成員方法，這顯然是一種對訪問許可權的破壞
 */