Class —— 反射基石

　　Java基本類之一，反射機制的基礎。其意義為：類的抽象，即對“類”做描述：比如類有修飾、欄位、方法等屬性，有獲得該類的所有方法、所有公有方法等方法。同時，Class也是Java型別中最重要的一種，表示原始型別（引用型別）及基本型別。

宣告

1.Class的原始碼太長，這裡分4部分解析，一些方法的實現原始碼較長，這裡就沒有貼出來了，我會著重將敘述其作用，至於其實現邏輯，以本人現有水平估計也很難一一講解清晰，大家姑且看之，若其中有錯誤地方或未講解明白的可留言探討。
2.閱讀該文前，若對反射和泛型知識有一定基礎最好。

原始碼

public final
    class
 
 Class<T> implements java.io.Serializable,
                            java.lang.reflect.GenericDeclaration,
                              java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {
    private static final int ANNOTATION= 0x00002000;//註釋型別
    private static
 
 final int ENUM      = 0x00004000;//列舉型別
    private static final int SYNTHETIC = 0x00001000;//合成型別，注0
    //列舉是一種類（class），註釋是一種介面（interface）
    private transient String name;//全限定名（包+類名）
    private native String getName0();//本地方法獲取name屬性
    //註冊本地方法
    private static native void registerNatives();
    static {
        registerNatives();
    }
    private
 
 Class() {}//唯一私有構造方法，說明Class不可由使用者構造例項
    public String toString() {
        //這裡重寫toString，只區別了介面和Class
        return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
            + getName();
    }
    //通過類全限定名獲得該類（或介面）的Class物件（載入該類）
    @CallerSensitive   //注1
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
    @CallerSensitive
    public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)
        throws ClassNotFoundException
    {
        //initialize : 是否立即初始化該類，注2
        //loader : 使用指定的類載入器載入
    }
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;
    //反射獲得該類例項物件
 @CallerSensitive
    public T newInstance()
        throws InstantiationException, IllegalAccessException
    {
    //JDK明言：本方法在當前Java記憶體模型下不一定是正確的
        //反射獲取該類例項物件，例項化物件不是通過new指令，而是直接
        //通過本地方法獲取類的公有構造方法（無參），然後通過Constructor的
        //newInstance();方法例項化物件
        //這個過程還要檢查是否有許可權反射例項化該物件
    }
    //快取上面方法已獲取的公有構造方法，供下次使用
    private volatile transient Constructor<T> cachedConstructor;
    //快取呼叫本方法的最初物件的類Class物件，供安全檢查使用，見注1
    private volatile transient Class<?>       newInstanceCallerCache;
    //判斷obj物件是否是該Class的例項
    public native boolean isInstance(Object obj);
    //判斷cls是否是呼叫者同一型別或其子類型別
    public native boolean isAssignableFrom(Class<?> cls);
    //判斷該Class是否是介面型別
    public native boolean isInterface();
    //判斷該Class是否是陣列型別
    public native boolean isArray();
    //判斷該Class是否是基本型別，注3（八大基本型別+一特殊基本型別）
    public native boolean isPrimitive();
    //判斷該Class是否是註釋型別
    public boolean isAnnotation() {
        return (getModifiers() & ANNOTATION) != 0;
    }
    //判斷該Class是否是合成型別
    public boolean isSynthetic() {
        return (getModifiers() & SYNTHETIC) != 0;
    }
    public String getName() {
        String name = this.name;
        if (name == null)
            this.name = name = getName0();//通過本地方法獲取全路徑類名
        return name;
    }
    //獲取載入該類的類載入器
    @CallerSensitive
    public ClassLoader getClassLoader() {
        ClassLoader cl = getClassLoader0();
        if (cl == null)
            return null;
        SecurityManager sm = System.getSecurityManager();//注5
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
        }
        return cl;
    }
    native ClassLoader getClassLoader0();
    //返回該類中變數欄位的型別變數陣列，按宣告順序排序，注4
    public TypeVariable<Class<T>>[] getTypeParameters() {
        if (getGenericSignature() != null)
            return (TypeVariable<Class<T>>[])getGenericInfo().getTypeParameters();
        else
            return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
    }
    //獲得該類的直接父類的Class物件，如果該類是介面，則返回null
    public native Class<? super T> getSuperclass();
    //返回帶引數化型別的直接父類的型別
    public Type getGenericSuperclass() {}
    //獲取該類的包路徑
    public Package getPackage() {
        return Package.getPackage(this);
    }
    //獲取該類直接實現的所有介面
    public native Class<?>[] getInterfaces();
    //獲取所有介面，同上面的不同之處在於，若超介面是引數化型別（泛型）則返回的是其實際型別
    public Type[] getGenericInterfaces() {
        if (getGenericSignature() != null)
            return getGenericInfo().getSuperInterfaces();
        else
            return getInterfaces();
    }
    /**返回陣列型別，若該類不是陣列，返回null
     * 如：A[] a = new A[];
     * a.getClass().getComponentType()返回的是A型別（全路徑名） 
     */
    public native Class<?> getComponentType();
    //返回這個類的修飾符的對應的int值，二者可通過Modifier.toString()轉換
    public native int getModifiers();
    //獲取該類的所有簽名（標記）列表
    public native Object[] getSigners();
    //設定該類的簽名，注意方法修飾是預設，所以只有同包下類可用
    native void setSigners(Object[] signers);
    /**
     * 以上兩個方法不是很懂具體用來幹什麼的，估計是和安全檢查什麼有關，因為
     * setSigners()是預設修飾，只能同包下訪問（這就是說，使用者是用不了的）
     */
}

注0：合成型別，參考：synthetic Java合成型別
注1：@CallerSensitive註解，參考：JVM註解@CallSensitive（HEL_WOR）
注2：類的初始化
　　forName()方法預設是初始化類，不需要載入的的時候同時初始化類，需用forName的過載函式。類的載入、初始化可參考：Java類的載入
注3：Java基本資料型別
　　除了8大基本型別，還有void，詳見：Java變數資料型別
注4：Java型別，詳見：Type Java型別。
注5：關於Java安全策略之安全管理器，現可以參考：java安全沙箱（四）（xionghuiCoder）

概述

　　Class類，表示Java的基礎型別（類+基本型別），是對Java類的抽象，描述的是類的資訊，包括類的修飾符（public/private/protect/default/static/final等）、類的型別（一般類、列舉、註釋、介面、陣列等）、類的構造器、類的欄位、類的方法等資訊。所以在看待Class相關問題的時候應該從所有類的共性這個角度去看。注意，這裡的類不是平常我們說的狹義上的類（class），而是廣義上，包括了像介面、註釋、陣列等型別的類，下面若不特殊宣告，類代表著廣義上的類。
　　每一個類在JVM記憶體中，有一個唯一的對應的Class物件，這個物件有著該類的描述資訊，所以執行時可以通過該Class類物件進行相應的操作，這就是Java的反射了。（Java基本型別也對應一個Class物件）

//獲得Class物件的方法
//1.通過 型別.class 獲得，適用於所有型別
Class str = String.class;
Class i = int.class;
Class d = Double[].class;
//2.通過 Object的getClass() 方法獲得，適用於所有非基本型別
A a = new A(); Class ac = a.getClass();
//3.通過 Class.forName(String name) 方法獲得
Class ac1 = Class.forName("com.fcc.test.A");//注意要用全限定名

原始碼詳解

1.forName
　　靜態方法，通過類的全限定名載入類，返回該類的Class物件，forName有兩個過載，forName(String)和forName(String, boolean, ClassLoader)，其中，第一個引數是類的全限定名，第二個引數是指載入該類的後是否初始化該類，預設是載入後並初始化該類，最後一個引數是指使用哪個類載入器載入該類，預設是使用當前類的類載入器載入該類。
2.newInstance
　　建立該Class物件對應的物件例項，只有當類具有公有的無參構造方法才能成功，否則拋異常，關於newInstance詳見：newInstance和new（編輯中）。
3.getClassLoader
　　獲得載入該類的類載入器，在本JVM（Oracle HotSopt），當本類的類載入器是引導類載入器（bootStrap）則返回的是null。（類的載入見上面注2。）
4.getTypeParameters
　　返回該類中宣告（定義）的類變數陣列，例如：

//關於TypeVariable詳見注3
public class Main<K, V> {
    public static void main(String[] args) throws Exception
    {
        Class cl = Main.class;
        TypeVariable[] types = cl.getTypeParameters();
        for(TypeVariable type : types){
            System.out.println(type.getName());
        }
    }
}
K
V

5.getSuperclass
　　獲得該Class的直接父類對應的Class物件，如果該Class是基本型別（包括void，注意是小寫的關鍵字void，不是大寫的類Void）、介面、註釋，則返回null。

Class c0 = Main.class;//類,返回直接父類,泛型當做普通類處理
Class c1 = EnumA.class;//列舉型別,預設繼承Enum類
Class c2 = int.class;//基本型別返回null
Class c3 = int[].class;//陣列統一返回 class Object
Class c4 = InterfaceB.class;//介面也是返回null
Class c5 = Deprecated.class;//註釋型別也返回null,c5.isInterface() 為true
System.out.println("類 : " + c0.getSuperclass());
System.out.println("列舉 : " + c1.getSuperclass());
System.out.println("基本型別 : " + c2.getSuperclass());
System.out.println("陣列 : " + c3.getSuperclass());
System.out.println("介面 : " + c4.getSuperclass());
System.out.println("註釋 : " + c5.getSuperclass());
//輸出結果
類 : class java.lang.Object
列舉 : class java.lang.Enum
基本型別 : null
陣列 : class java.lang.Object
介面 : null
註釋 : null

6.getGenericSuperclass
　　獲得直接父類的型別，可以理解為在5的基礎上，如果其是泛型，再獲得其型別原型（但需要繼承時顯式表示）。

public class Main<K, V> {
    public static void main(String[] args) throws Exception
    {
        Class c0 = ClassA.class;
        Class c1 = EnumA.class;//列舉型別,預設繼承Enum類
        Class c2 = int.class;//基本型別返回null
        Class c3 = ClassA[].class;//陣列統一返回 class Object
        Class c4 = InterfaceB.class;//介面也是返回null
        Class c5 = Deprecated.class;//註釋型別也返回null
        System.out.println("類 : " + c0.getGenericSuperclass());
        System.out.println("列舉 : " + c1.getGenericSuperclass());
        System.out.println("基本型別 : " + c2.getGenericSuperclass());
        System.out.println("陣列 : " + c3.getGenericSuperclass());
        System.out.println("介面 : " + c4.getGenericSuperclass());
        System.out.println("註釋 : " + c5.getGenericSuperclass());
        System.out.println(c2.isInterface());
    }
}
class ClassA<K,V> extends Main<K,V>{}//注1
//輸出結果
類 : com.fcc.test.Main<K, V>
列舉 : java.lang.Enum<com.fcc.test.EnumA>
基本型別 : null
陣列 : class java.lang.Object
介面 : null
註釋 : null
注1：如果是以下形式
class ClassA extends Main{}
則輸出為：類 : com.fcc.test.Main

7.getInterfaces
8.getGenericInterfaces
　　getInterfaces/getGenericInterfaces這一對同getSuperclass/getGenericSuperclass類似，getInterfaces/getGenericInterfaces前者是獲得該類直接實現的所有介面（不包括介面的父介面，也不包括父類實現的介面），後者是，如果介面是泛型，還原泛型的原型（但需要實現時顯式表示，這一點同getGenericSuperclass類似）。不過不管是哪一對，要注意，返回值型別的不同。

Class c0 = ClassB.class;
Class[] ifaces = c0.getInterfaces();
for(Class c : ifaces){
    System.out.println(c);
}
Type[] ifaces1 = c0.getGenericInterfaces();
for(Type c : ifaces1){
    System.out.println(c);
}
class ClassB<E> extends ClassA implements InterfaceB<E>{}
//輸出結果
interface com.fcc.test.InterfaceB
com.fcc.test.InterfaceB<E>