Java基礎之深入理解Class對象與反射機制

深入理解Class對象

RRIT及Class對象的概念

RRIT（Run-Time Type Identification）運行時類型識別。在《Thinking in Java》一書第十四章中有提到，它的功能是在運行時識別對象的類型和類信息。有兩種主要方式：“傳統的”RTTI（它假定我們在編譯時已經知道所有類型）和“反射”機制（它允許我們在運行時發現和使用類信息）。

類是程序的一部分，每個類都有一個類對象。換句話說，無論何時編寫和編譯新類，都會生成一個Class對象（更恰當地說，保存在相同名稱的A.class文件中）。當第一次使用所有類時，它們都被動態地加載到JVM中。例如，我們編寫了一個Test類並編譯它來生成Test。班級。此時，Test類的Class對象保存在類文件中。當我們新建一個對象或引用一個靜態成員變量時，Java虛擬機（JVM）中的類加載器子系統將相應的類對象加載到JVM中，然后JVM從這個類型的信息中創建我們需要的類對象，或者提供靜態變量的參考值。應當注意，無論創建了多少實例對象，手動編寫的每個類類類在JVM中都只有一個Class對象，也就是說，每個類在內存中都具有並且只有一個對應的Class對象。

Test t1 = new Test();
Test t2 = new Test();
Test t3 = new Test();

如上所示，實際上JVM內存中只存有一個Test的Class對象。

Class類，類類也是Java中存在的一個真實類。JDK的Lang軟件包。類類的實例表示Java應用程序運行時的類枚舉或接口和注釋（每個Java類運行時被表示為JVM中的類對象），類對象可以通過類名來獲得。類，類型。getClass()，Class.forName(“類名”)。數組還映射到一個類對象，該類對象由具有相同元素類型和維度的所有數組共享。基本類型布爾、字節、char、.、int、long、float、double和關鍵詞void也表示為類對象。

ublic final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
    private static final int ANNOTATION= 0x00002000;
    private static final int ENUM      = 0x00004000;
    private static final int SYNTHETIC = 0x00001000;

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.   //私有構造器，只有JVM才能調用創建Class對象
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }

到這我們也就可以得出以下幾點信息：

• Class類也是類的一種，與class關鍵字是不一樣的。

• 手動編寫的類被編譯后會產生一個Class對象，其表示的是創建的類的類型信息，而且這個Class對象保存在同名.class的文件中(字節碼文件)

• 每個通過關鍵字class標識的類，在內存中有且只有一個與之對應的Class對象來描述其類型信息，無論創建多少個實例對象，其依據的都是用一個Class對象。

• Class類只存私有構造函數，因此對應Class對象只能有JVM創建和加載

• Class類的對象作用是運行時提供或獲得某個對象的類型信息，這點對於反射技術很重要(關於反射稍后分析)。

Class對象的加載及獲取

Class對象的加載

正如我們前面提到的，類對象是由JVM加載的，所以什么時候加載呢？實際上，所有類在第一次使用時都動態地加載到JVM中。當程序創建對該類的第一個靜態成員引用時，它加載使用的類（實際加載該類的字節碼文件）。注意，使用新操作符創建類的新實例對象也被視為對類的靜態成員（構造函數也是一個類）的引用。看來Java程序在開始運行之前沒有完全加載到內存中，而且它們的所有部分都按需加載。因此，當使用這個類時，類加載器首先檢查這個類的Class對象是否已經被加載（類的實例對象是根據Class對象中的類型信息創建的）。如果未加載，則默認的類加載Class對象將以相同的名稱保存。編譯后的類文件。當該類的字節碼文件被加載時，它們必須接受相關的驗證，以確保它們不被破壞，並且不包含壞的Java代碼（這是Java的安全機制檢測）。在沒有問題之后，它們將被動態地加載到內存中，這相當於Cl。ass對象被加載到內存中（畢竟，類字節碼文件保存Cl ass對象），並且還可以用於創建類的所有實例對象。

 

類加載的過程 :
1. 加載
在加載階段，虛擬機需要完成3件事：
（1）通過一個類的全限定名（org/fenixsoft/clazz/TestClass）獲取定義此類的二進制字節流（.class文件）;
（2）將這個字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構;
（3）在內存中生成一個代表這個類的 java.lang.Class 對象，作為方法區這個類的各種數據的訪問入口;
2. 驗證
驗證階段是非常重要的，這個階段是否嚴謹，直接決定了Java虛擬機是否能承受惡意代碼的攻擊，從執行性能的角度上講，驗證階段的工作量在虛擬機的類加載子系統中又占了相當大的一部分。驗證階段大致上完成下面4個階段的驗證動作：
（1）文件格式驗證
驗證字節流是否符合Class文件格式的規范，並且能被當前版本的虛擬機處理;
這階段的驗證是基於二進制字節流進行的，只有通過了這個階段的驗證，字節流才會進入內存的方法區進行儲存，所以后面的3個驗證階段全部是基於方法區的存儲結構進行的，不會再直接操作字節流。
（2）元數據驗證
對字節碼描述的信息進行語義分析，以保證其描述的信息符合Java語言規范的要求，保證不存在不符合Java語言規范的元數據信息;
（3）字節碼驗證
通過數據流和控制流分析，確定程序是語義是合法的、符合邏輯的，保證被校驗的方法在運行時不會做出危害虛擬機安全的事件;
（4）符號引用驗證
可以看作是對類自身以外（常量池中各種符號引用）的信息進行匹配性校驗，確保解析動作能正常執行;
3. 准備
准備階段是正式為類變量分配內存並設置類變量初始值階段，這些變量所使用的內存都將在方法區中進行分配。這里進行內存分配僅僅是類變量（被static修飾的變量），而不包括實例變量，實例變量將在對象實例化時隨着對象一起分配在Java堆中;
4. 解析
解析階段是虛擬機將常量池內的符號引用替換為直接引用的過程。解析動作主要針對類或接口、字段、類方法、方法類型、方法句柄和調用點限定符7類符號引用進行;
5. 初始化
初始化階段才真正開始執行類中定義的Java程序代碼（或者說是字節碼）。初始化是如何被觸發的：
（1）遇到new、getstatic、putstatic或involestatic這4條指令時;
（2）使用 java.lang.reflect 包的方法對類進行反射調用的時候;
（3）初始化一個類時，如果父類還沒被初始化，則先觸發父類的初始化;
（4）虛擬機啟動時，用戶需要指定一個要執行的主類 （包含main()方法的那個類），虛擬機會先初始化這個主類;
（5）如果一個 java.lang.invoke.MethodHandle 實例最后解析的結果是 REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，若句柄所對應的類沒有進行過初始化，則將它初始化;

上文源自《深入理解java虛擬機》一書，大家可以去讀一下，這本書基本上是java程序猿學習必讀之一了。在此就不深入展開了，因為這又是另一個JVM領域了。 以后如果寫了該方面的文章，會貼到這里。

Class對象的獲取

Class對象的獲取主要有3種：

• 通過實例getClass（）方法獲取
• Class.forName方法獲取
• 類字面常量獲取

通過實例getClass（）方法獲取

    Test t1 = new Test();
    Class clazz=test.getClass();
    System.out.println("clazz:"+clazz.getName());

getClass()是從頂級類Object繼承而來的，它將返回表示該對象的實際類型的Class對象引用。

Class.forName方法獲取

forName方法是Class類的靜態成員方法，記住所有Class對象都源自這個Class類，因此Class類中定義的方法適用於所有Class對象。這里，通過forName方法，我們可以獲得Test類的相應Class對象引用。注意，當調用forName方法時，您需要捕獲一個名為ClassNotFoundException的異常，因為forName方法無法檢測編譯器中與其傳遞的字符串（是否有.class文件）對應的類的存在，並且只能在程序的運行時進行檢查。如果不存在，將引發ClassNotFoundException異常。

使用forName方式會觸發類的初始化，與之相比的是使用類字面常量獲取

類字面常量獲取

//字面常量的方式獲取Class對象
Class clazz = Test.class;

這不僅更簡單，而且更安全，因為它是在編譯時檢查的（因此不需要放在try語句塊中）。而且它消除了對forName()方法的調用，因此也更有效。注意，當您使用“.“類”創建對Class對象的引用，Class對象不會自動初始化。注意，當您使用“.“類”創建對Classs對象的引用，Class對象不會自動初始化。使用該類的准備實際上包括三個步驟：

1. 加載，這是由類加載器執行的，該步驟將查找字節碼（通常在classpath所指定的路徑中查找，但這並非是必需的），並從這些字節碼中創建一個Class對象。
2. 鏈接。在鏈接階段將驗證類中的字節碼，為靜態域分布存儲空間，並且如果必需的話，將解析這個類創建的對其他類的所有引用。
3. 初始化。如果該類具有超類，則對其初始化，執行靜態初始化器和靜態初始化塊。

class Initable{
     static final int staticFinal = 47;
     static final int staticFinal2 = ClassInitialization.rand.nextInt(1000);
     static {
          System.out.ptintln("Initializing Initable");
     }
}

class Initable2 {
     static int staticNonFinal = 147;
     static {
          System.out.println("Initializing Initable2");
     }
}

class Initable3 {
     static int staticNonFinal = 74;
     static {
          System.out.println("Initializing Initable3");
     }
}

public class ClassInitialization {
     public static Random rand = new Random(47);
     public static void main(String[] args) throws Exception {
          Class initable = Initable.class;
          System.out.println("After creating Initable ref");
          System.out.println(Initable.staticFinal);
          System.out.println(Initable.staticFinal2);
          System.out.println(Initable2.staticNonFinal);
          Clas initable3 = Class.forName("Initable3");
          System.out.println("After creating Initable3 ref");
          System.out.println(Initable3.staticNonFinal);
     }
}

/* output
After creating Initable ref
47
Initializing Initable
258
Initializing Initable2
147
Initializing Initable3
After creating Initable ref
74

如果一個static final值是編譯器常量，就像Initable.staticFinal那樣，那么這個值不需要對Initable類進行初始化就可以被讀取。但是，如果只是將一個域設置為static和final的，還不足以確保這種行為，例如，對Initable.staticFinal2的訪問將強制進行類的初始化，因為它不是一個編譯期常量。

如果靜態域不是最終的，則總是需要在讀取之前進行鏈接（為域分配存儲空間）和初始化（初始化存儲空間），如訪問Initable2所示。靜態非決賽。從輸出結果可以看出，通過文字常數獲取獲得的Initable類的Class對象不觸發Initable類的初始化，這也驗證了前面的分析。同時，還發現不可逆的。staticFinal變量不觸發初始化，因為staticFinal在編譯時屬於靜態常數，並且在編譯階段通過常數傳播優化。公式將Initable類的常量staticFinal存儲在一個名為NotInitialization類的常量池中。將來，對常量staticFinal of Initable類的引用實際上被轉換成對其自己的常量NotInitialization類池的引用。因此，在編譯之后，對編譯時間常數的引用將在NotInitialization類的常量池中獲得，這也是引用編譯時間。靜態常數不觸發Initable類初始化的一個重要原因。然而，不適宜的。然后調用staticFinal2變量來觸發Initable類的初始化。注意，盡管staticFinal2由static和final修改，但它的值在編譯時無法確定。因此，staticFinal2不是編譯時間常數，在使用此變量之前，必須初始化Initable類。Initable2和Initable3是靜態成員變量，而不是編譯時常數，引用觸發初始化。至於forName方法獲取Class對象，初始化被綁定到.，前面已經對此進行了分析。

instanceof與Class的等價性

關於instanceof 關鍵字，它返回一個boolean類型的值，意在告訴我們對象是不是某個特定的類型實例。如下，在強制轉換前利用instanceof檢測obj是不是Animal類型的實例對象，如果返回true再進行類型轉換，這樣可以避免拋出類型轉換的異常(ClassCastException)

而isInstance方法則是Class類中的一個Native方法，也是用於判斷對象類型的，看個簡單例子：

事實上instanceOf 與isInstance方法產生的結果是相同的。

class A {}

class B extends A {}

public class C {
  static void test(Object x) {
    print("Testing x of type " + x.getClass());
    print("x instanceof A " + (x instanceof A));
    print("x instanceof B "+ (x instanceof B));
    print("A.isInstance(x) "+ A.class.isInstance(x));
    print("B.isInstance(x) " +
      B.class.isInstance(x));
    print("x.getClass() == A.class " +
      (x.getClass() == A.class));
    print("x.getClass() == B.class " +
      (x.getClass() == B.class));
    print("x.getClass().equals(A.class)) "+
      (x.getClass().equals(A.class)));
    print("x.getClass().equals(B.class)) " +
      (x.getClass().equals(B.class)));
  }
  public static void main(String[] args) {
    test(new A());
    test(new B());
  } 
}

/* output
Testing x of type class com.zejian.A
x instanceof A true
x instanceof B false //父類不一定是子類的某個類型
A.isInstance(x) true
B.isInstance(x) false
x.getClass() == A.class true
x.getClass() == B.class false
x.getClass().equals(A.class)) true
x.getClass().equals(B.class)) false
---------------------------------------------
Testing x of type class com.zejian.B
x instanceof A true
x instanceof B true
A.isInstance(x) true
B.isInstance(x) true
x.getClass() == A.class false
x.getClass() == B.class true
x.getClass().equals(A.class)) false
x.getClass().equals(B.class)) true

反射

反射機制是在運行狀態下可以知道任何類的所有屬性和方法，並且可以調用任何對象的任何方法和屬性。獲得的動態信息和對象的動態調用方法的功能被稱為Java語言的反射機制。反射技術一直是爪哇的一個亮點，它也是大多數框架（如Spring／MybATIS等）要實現的骨干。在Java中，類類和Java。反射類庫共同為反射技術提供了充分的支持。在反射包中，我們通常使用構造函數類來構造由類對象表示的類。通過使用Constructor類，我們可以在運行時動態創建對象以及由Class對象表示的Field類。通過使用Constructor類，我們可以在運行時動態修改成員變量（包括私有）和由Class對象表示的方法類的屬性值。方法，通過該方法可以動態調用對象的方法（包括私有類），下面將分別解釋這些重要的類。

Constructor類及其用法

Constructor類存在於反射包(java.lang.reflect)中，反映的是Class 對象所表示的類的構造方法。獲取Constructor對象是通過Class類中的方法獲取的，Class類與Constructor相關的主要方法如下：

下面看一個簡單例子來了解Constructor對象的使用：

public class ConstructionTest implements Serializable {
    public static void main(String[] args) throws Exception {

        Class<?> clazz = null;

        //獲取Class對象的引用
        clazz = Class.forName("com.example.javabase.User");

        //第一種方法，實例化默認構造方法，User必須無參構造函數,否則將拋異常
        User user = (User) clazz.newInstance();
        user.setAge(20);
        user.setName("Jack");
        System.out.println(user);

        System.out.println("--------------------------------------------");

        //獲取帶String參數的public構造函數
        Constructor cs1 =clazz.getConstructor(String.class);
        //創建User
        User user1= (User) cs1.newInstance("hiway");
        user1.setAge(22);
        System.out.println("user1:"+user1.toString());

        System.out.println("--------------------------------------------");

        //取得指定帶int和String參數構造函數,該方法是私有構造private
        Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
        //由於是private必須設置可訪問
        cs2.setAccessible(true);
        //創建user對象
        User user2= (User) cs2.newInstance(25,"hiway2");
        System.out.println("user2:"+user2.toString());

        System.out.println("--------------------------------------------");

        //獲取所有構造包含private
        Constructor<?> cons[] = clazz.getDeclaredConstructors();
        // 查看每個構造方法需要的參數
        for (int i = 0; i < cons.length; i++) {
            //獲取構造函數參數類型
            Class<?> clazzs[] = cons[i].getParameterTypes();
            System.out.println("構造函數["+i+"]:"+cons[i].toString() );
            System.out.print("參數類型["+i+"]:(");
            for (int j = 0; j < clazzs.length; j++) {
                if (j == clazzs.length - 1)
                    System.out.print(clazzs[j].getName());
                else
                    System.out.print(clazzs[j].getName() + ",");
            }
            System.out.println(")");
        }
    }
}


class User {
    private int age;
    private String name;
    public User() {
        super();
    }
    public User(String name) {
        super();
        this.name = name;
    }

    /**
     * 私有構造
     * @param age
     * @param name
     */
    private User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

/* output 
User{age=20, name='Jack'}
--------------------------------------------
user1:User{age=22, name='hiway'}
--------------------------------------------
user2:User{age=25, name='hiway2'}
--------------------------------------------
構造函數[0]:private com.example.javabase.User(int,java.lang.String)
參數類型[0]:(int,java.lang.String)
構造函數[1]:public com.example.javabase.User(java.lang.String)
參數類型[1]:(java.lang.String)
構造函數[2]:public com.example.javabase.User()
參數類型[2]:()

關於Constructor類本身一些常用方法如下(僅部分，其他可查API)

Field類及其用法

Field 提供有關類或接口的單個字段的信息，以及對它的動態訪問權限。反射的字段可能是一個類（靜態）字段或實例字段。同樣的道理，我們可以通過Class類的提供的方法來獲取代表字段信息的Field對象，Class類與Field對象相關方法如下：

下面的代碼演示了上述方法的使用過程

public class ReflectField {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> clazz = Class.forName("reflect.Student");
        //獲取指定字段名稱的Field類,注意字段修飾符必須為public而且存在該字段,
        // 否則拋NoSuchFieldException
        Field field = clazz.getField("age");
        System.out.println("field:"+field);

        //獲取所有修飾符為public的字段,包含父類字段,注意修飾符為public才會獲取
        Field fields[] = clazz.getFields();
        for (Field f:fields) {
            System.out.println("f:"+f.getDeclaringClass());
        }

        System.out.println("================getDeclaredFields====================");
        //獲取當前類所字段(包含private字段),注意不包含父類的字段
        Field fields2[] = clazz.getDeclaredFields();
        for (Field f:fields2) {
            System.out.println("f2:"+f.getDeclaringClass());
        }
        //獲取指定字段名稱的Field類,可以是任意修飾符的自動,注意不包含父類的字段
        Field field2 = clazz.getDeclaredField("desc");
        System.out.println("field2:"+field2);
    }
    /**
      輸出結果: 
     field:public int reflect.Person.age
     f:public java.lang.String reflect.Student.desc
     f:public int reflect.Person.age
     f:public java.lang.String reflect.Person.name

     ================getDeclaredFields====================
     f2:public java.lang.String reflect.Student.desc
     f2:private int reflect.Student.score
     field2:public java.lang.String reflect.Student.desc
     */
}

class Person{
    public int age;
    public String name;
    //省略set和get方法
}

class Student extends Person{
    public String desc;
    private int score;
    //省略set和get方法
}

應當注意，如果我們不希望獲得其父類的字段，則需要使用Class類的getDeclared./getDeclaredFields方法來獲得字段。如果需要聯合地獲取父類的字段，我們可以使用Class類的get./getFi.，但是只能獲得由public修飾的字段，而不能獲得父類的私有字段。

其中的set(Object obj, Object value)方法是Field類本身的方法，用於設置字段的值，而get(Object obj)則是獲取字段的值，當然關於Field類還有其他常用的方法如下：

 

這些方法可能更常用。實際上，Field類還提供了專門用於基本數據類型的方法，例如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等。這里沒有列出全部。您可以在需要時查看API文檔。應特別注意由final關鍵字修改的Field字段是安全的，並且可以在運行時接受任何修改，但其實際值最終不會改變。

Method類及其用法

Method 提供關於類或接口上單獨某個方法（以及如何訪問該方法）的信息，所反映的方法可能是類方法或實例方法（包括抽象方法）。下面是Class類獲取Method對象相關的方法：

同樣通過案例演示上述方法：

import java.lang.reflect.Method;

public class ReflectMethod  {


    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {

        Class clazz = Class.forName("reflect.Circle");

        //根據參數獲取public的Method,包含繼承自父類的方法
        Method method = clazz.getMethod("draw",int.class,String.class);

        System.out.println("method:"+method);

        //獲取所有public的方法:
        Method[] methods =clazz.getMethods();
        for (Method m:methods){
            System.out.println("m::"+m);
        }

        System.out.println("=========================================");

        //獲取當前類的方法包含private,該方法無法獲取繼承自父類的method
        Method method1 = clazz.getDeclaredMethod("drawCircle");
        System.out.println("method1::"+method1);
        //獲取當前類的所有方法包含private,該方法無法獲取繼承自父類的method
        Method[] methods1=clazz.getDeclaredMethods();
        for (Method m:methods1){
            System.out.println("m1::"+m);
        }
    }

/**
     輸出結果:
     method:public void reflect.Shape.draw(int,java.lang.String)

     m::public int reflect.Circle.getAllCount()
     m::public void reflect.Shape.draw()
     m::public void reflect.Shape.draw(int,java.lang.String)
     m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
     m::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
     m::public final void java.lang.Object.wait() throws java.lang.InterruptedException
     m::public boolean java.lang.Object.equals(java.lang.Object)
     m::public java.lang.String java.lang.Object.toString()
     m::public native int java.lang.Object.hashCode()
     m::public final native java.lang.Class java.lang.Object.getClass()
     m::public final native void java.lang.Object.notify()
     m::public final native void java.lang.Object.notifyAll()

     =========================================
     method1::private void reflect.Circle.drawCircle()

     m1::public int reflect.Circle.getAllCount()
     m1::private void reflect.Circle.drawCircle()
     */
}

class Shape {
    public void draw(){
        System.out.println("draw");
    }

    public void draw(int count , String name){
        System.out.println("draw "+ name +",count="+count);
    }

}
class Circle extends Shape{

    private void drawCircle(){
        System.out.println("drawCircle");
    }
    public int getAllCount(){
        return 100;
    }
}

在通過getMethods方法獲取Method對象時，會把父類的方法也獲取到，如上的輸出結果，把Object類的方法都打印出來了。而getDeclaredMethod/getDeclaredMethods方法都只能獲取當前類的方法。我們在使用時根據情況選擇即可。

在上述代碼中調用方法，使用了Method類的invoke(Object obj,Object... args)第一個參數代表調用的對象，第二個參數傳遞的調用方法的參數。這樣就完成了類方法的動態調用。

 

 

getReturnType方法/getGenericReturnType方法都是獲取Method對象表示的方法的返回類型，只不過前者返回的Class類型后者返回的Type(前面已分析過)，Type就是一個接口而已，在Java8中新增一個默認的方法實現，返回的就參數類型信息

。