java基礎：深刻理解Class對象與反射機制

時間 2019-11-07

標籤 java 基礎深刻理解 class 對象反射機制欄目 Java 简体版

原文原文鏈接

其餘更多java基礎文章：
java基礎學習(目錄)java

深刻理解Class對象

RRIT及Class對象的概念

RRIT（Run-Time Type Identification）運行時類型識別。在《Thinking in Java》一書第十四章中有提到，其做用是在運行時識別一個對象的類型和類的信息。主要有兩種方式：一種是「傳統的」RTTI，它假定咱們在編譯時已經知道了全部的類型；另外一種是「反射」機制，它容許咱們在運行時發現和使用類的信息。數組

類是程序的一部分，每一個類都有一個class對象。換言之，每當編寫而且編譯了一個新類，就會產生一個Class對象（更恰當地說，是被保存在一個同名的.class文件中）。全部的類都是在對其第一次使用時，動態加載到JVM中的。例如咱們寫了一個Test類，編譯後生成了Test.class，此時咱們的Test類的Class對象就保存在class文件中。當咱們new一個新對象或者引用靜態成員變量時，Java虛擬機(JVM)中的類加載器子系統會將對應Class對象加載到JVM中，而後JVM再根據這個類型信息相關的Class對象建立咱們須要實例對象或者提供靜態變量的引用值。須要特別注意的是，手動編寫的每一個class類，不管建立多少個實例對象，在JVM中都只有一個Class對象，即在內存中每一個類有且只有一個相對應的Class對象。安全

Test t1 = new Test();
Test t2 = new Test();
Test t3 = new Test();
複製代碼

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

Class類，Class類也是一個實實在在的類，存在於JDK的java.lang包中。Class類的實例表示java應用運行時的類(class ans enum)或接口(interface and annotation)（每一個java類運行時都在JVM裏表現爲一個class對象，可經過類名.class、類型.getClass()、Class.forName("類名")等方法獲取class對象）。數組一樣也被映射爲爲class 對象的一個類，全部具備相同元素類型和維數的數組都共享該 Class 對象。基本類型boolean，byte，char，short，int，long，float，double和關鍵字void一樣表現爲 class 對象。數據結構

public 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關鍵字是不同的。dom
手動編寫的類被編譯後會產生一個Class對象，其表示的是建立的類的類型信息，並且這個Class對象保存在同名.class的文件中(字節碼文件)ide
每一個經過關鍵字class標識的類，在內存中有且只有一個與之對應的Class對象來描述其類型信息，不管建立多少個實例對象，其依據的都是用一個Class對象。函數
Class類只存私有構造函數，所以對應Class對象只能有JVM建立和加載post
Class類的對象做用是運行時提供或得到某個對象的類型信息，這點對於反射技術很重要(關於反射稍後分析)。

Class對象的加載及獲取

Class對象的加載

前面咱們已提到過，Class對象是由JVM加載的，那麼其加載時機是？實際上全部的類都是在對其第一次使用時動態加載到JVM中的，當程序建立第一個對類的靜態成員引用時，就會加載這個被使用的類(實際上加載的就是這個類的字節碼文件)，注意，使用new操做符建立類的新實例對象也會被看成對類的靜態成員的引用(構造函數也是類的靜態方法)，由此看來Java程序在它們開始運行以前並不是被徹底加載到內存的，其各個部分是按需加載，因此在使用該類時，類加載器首先會檢查這個類的Class對象是否已被加載(類的實例對象建立時依據Class對象中類型信息完成的)，若是尚未加載，默認的類加載器就會先根據類名查找.class文件(編譯後Class對象被保存在同名的.class文件中)，在這個類的字節碼文件被加載時，它們必須接受相關驗證，以確保其沒有被破壞而且不包含不良Java代碼(這是java的安全機制檢測)，徹底沒有問題後就會被動態加載到內存中，此時至關於Class對象也就被載入內存了(畢竟.class字節碼文件保存的就是Class對象)，同時也就能夠被用來建立這個類的全部實例對象。

類加載的過程 :
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方法獲取

try{
      //經過Class.forName獲取Test類的Class對象
      Class clazz=Class.forName("com.hiway.Test");
      System.out.println("clazz:"+clazz.getName());
    }catch (ClassNotFoundException e){
      e.printStackTrace();
    }
複製代碼

forName方法是Class類的一個static成員方法，記住全部的Class對象都源於這個Class類，所以Class類中定義的方法將適應全部Class對象。這裏經過forName方法，咱們能夠獲取到Test類對應的Class對象引用。注意調用forName方法時須要捕獲一個名稱爲ClassNotFoundException的異常，由於forName方法在編譯器是沒法檢測到其傳遞的字符串對應的類是否存在的（是否有.class文件），只能在程序運行時進行檢查，若是不存在就會拋出ClassNotFoundException異常。

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

類字面常量獲取

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

這樣作不只更簡單，並且更安全，由於它在編譯時就會受到檢查（所以不須要置於try語句塊中）。而且它根除了對forName()方法的調用，因此也更高效。注意，有一點頗有趣，當使用「.class」來建立對Class對象的引用時，不會自動地初始化該Class對象，爲了使用類而作的準備工做實際包含三個步驟：

加載，這是由類加載器執行的，該步驟將查找字節碼（一般在classpath所指定的路徑中查找，但這並不是是必需的），並從這些字節碼中建立一個Class對象。
連接。在連接階段將驗證類中的字節碼，爲靜態域分佈存儲空間，而且若是必需的話，將解析這個類建立的對其餘類的全部引用。
初始化。若是該類具備超類，則對其初始化，執行靜態初始化器和靜態初始化塊。

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的訪問將強制進行類的初始化，由於它不是一個編譯期常量。

若是一個static域不是final的， 那麼在對它訪問時，老是要求在它被讀取以前，要先進行連接（爲這個域分配存儲空間）和初始化（初始化該存儲空間），就像在對Initable2.staticNonFinal的訪問中所看到的那樣。從輸出結果來看，能夠發現，經過字面常量獲取方式獲取Initable類的Class對象並無觸發Initable類的初始化，這點也驗證了前面的分析，同時發現調用Initable.staticFinal變量時也沒有觸發初始化，這是由於staticFinal屬於編譯期靜態常量，在編譯階段經過常量傳播優化的方式將Initable類的常量staticFinal存儲到了一個稱爲NotInitialization類的常量池中，在之後對Initable類常量staticFinal的引用實際都轉化爲對NotInitialization類對自身常量池的引用，因此在編譯期後，對編譯期常量的引用都將在NotInitialization類的常量池獲取，這也就是引用編譯期靜態常量不會觸發Initable類初始化的重要緣由。
但在以後調用了Initable.staticFinal2變量後就觸發了Initable類的初始化，注意staticFinal2雖然被static和final修飾，但其值在編譯期並不能肯定，所以staticFinal2並非編譯期常量， 使用該變量必須先初始化Initable類。Initable2和Initable3類中都是靜態成員變量並不是編譯期常量，引用都會觸發初始化。至於forName方法獲取Class對象，確定會觸發初始化，這點在前面已分析過。

instanceof與Class的等價性

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

public void cast2(Object obj){
    if(obj instanceof Animal){
          Animal animal= (Animal) obj;
      }
}
複製代碼

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

public void cast2(Object obj){
        //instanceof關鍵字
        if(obj instanceof Animal){
            Animal animal= (Animal) obj;
        }

        //isInstance方法
        if(Animal.class.isInstance(obj)){
            Animal animal= (Animal) obj;
        }
  }
複製代碼

事實上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語言的反射機制。一直以來反射技術都是Java中的閃亮點，這也是目前大部分框架(如Spring/Mybatis等)得以實現的支柱。在Java中，Class類與java.lang.reflect類庫一塊兒對反射技術進行了全力的支持。在反射包中，咱們經常使用的類主要有Constructor類表示的是Class 對象所表示的類的構造方法，利用它能夠在運行時動態建立對象、Field表示Class對象所表示的類的成員變量，經過它能夠在運行時動態修改爲員變量的屬性值(包含private)、Method表示Class對象所表示的類的成員方法，經過它能夠動態調用對象的方法(包含private)，下面將對這幾個重要類進行分別說明。

Constructor類及其用法

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

方法返回值	方法名稱	方法說明
static Class<?>	forName(String className)	返回與帶有給定字符串名的類或接口相關聯的 Class 對象。
Constructor	getConstructor(Class<?>... parameterTypes)	返回指定參數類型、具備public訪問權限的構造函數對象
Constructor<?>[]	getConstructors()	返回全部具備public訪問權限的構造函數的Constructor對象數組
Constructor	getDeclaredConstructor(Class<?>... parameterTypes)	返回指定參數類型、全部聲明的（包括private）構造函數對象
Constructor<?>[]	getDeclaredConstructor()	返回全部聲明的（包括private）構造函數對象
T	newInstance()	調用無參構造器建立此 Class 對象所表示的類的一個新實例。

下面看一個簡單例子來了解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)

方法返回值	方法名稱	方法說明
Class	getDeclaringClass()	返回 Class 對象，該對象表示聲明由此 Constructor 對象表示的構造方法的類,其實就是返回真實類型（不包含參數）
Type[]	getGenericParameterTypes()	按照聲明順序返回一組 Type 對象，返回的就是 Constructor對象構造函數的形參類型。
String	getName()	以字符串形式返回此構造方法的名稱。
Class<?>[]	getParameterTypes()	按照聲明順序返回一組 Class 對象，即返回Constructor 對象所表示構造方法的形參類型
T	newInstance(Object... initargs)	使用此 Constructor對象表示的構造函數來建立新實例
String	toGenericString()	返回描述此 Constructor 的字符串，其中包括類型參數。

代碼演示以下：

Constructor cs3 = clazz.getDeclaredConstructor(int.class,String.class);
        System.out.println("-----getDeclaringClass-----");
        Class uclazz=cs3.getDeclaringClass();
//Constructor對象表示的構造方法的類
        System.out.println("構造方法的類:"+uclazz.getName());

        System.out.println("-----getGenericParameterTypes-----");
//對象表示此 Constructor 對象所表示的方法的形參類型
        Type[] tps=cs3.getGenericParameterTypes();
        for (Type tp:tps) {
            System.out.println("參數名稱tp:"+tp);
        }
        System.out.println("-----getParameterTypes-----");
//獲取構造函數參數類型
        Class<?> clazzs[] = cs3.getParameterTypes();
        for (Class claz:clazzs) {
            System.out.println("參數名稱:"+claz.getName());
        }
        System.out.println("-----getName-----");
//以字符串形式返回此構造方法的名稱
        System.out.println("getName:"+cs3.getName());

        System.out.println("-----getoGenericString-----");
//返回描述此 Constructor 的字符串，其中包括類型參數。
        System.out.println("getoGenericString():"+cs3.toGenericString());

/* output 
-----getDeclaringClass-----
構造方法的類:com.example.javabase.User
-----getGenericParameterTypes-----
參數名稱tp:int
參數名稱tp:class java.lang.String
-----getParameterTypes-----
參數名稱:int
參數名稱:java.lang.String
-----getName-----
getName:com.example.javabase.User
-----getoGenericString-----
getoGenericString():private com.example.javabase.User(int,java.lang.String)
複製代碼

Field類及其用法

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

方法返回值	方法名稱	方法說明
Field	getDeclaredField(String name)	獲取指定name名稱的(包含private修飾的)字段，不包括繼承的字段
Field[]	getDeclaredField()	獲取Class對象所表示的類或接口的全部(包含private修飾的)字段,不包括繼承的字段
Field	getField(String name)	獲取指定name名稱、具備public修飾的字段，包含繼承字段
Field[]	getField()	獲取修飾符爲public的字段，包含繼承字段

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

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類的getDeclaredField/getDeclaredFields方法來獲取字段便可，假若須要連帶獲取到父類的字段，那麼請使用Class類的getField/getFields，可是也只能獲取到public修飾的的字段，沒法獲取父類的私有字段。下面將經過Field類自己的方法對指定類屬性賦值，代碼演示以下：

//獲取Class對象引用
Class<?> clazz = Class.forName("reflect.Student");

Student st= (Student) clazz.newInstance();
//獲取父類public字段並賦值
Field ageField = clazz.getField("age");
ageField.set(st,18);
Field nameField = clazz.getField("name");
nameField.set(st,"Lily");

//只獲取當前類的字段,不獲取父類的字段
Field descField = clazz.getDeclaredField("desc");
descField.set(st,"I am student");
Field scoreField = clazz.getDeclaredField("score");
//設置可訪問，score是private的
scoreField.setAccessible(true);
scoreField.set(st,88);
System.out.println(st.toString());

//輸出結果：Student{age=18, name='Lily ,desc='I am student', score=88} //獲取字段值 System.out.println(scoreField.get(st)); // 88 複製代碼

其中的set(Object obj, Object value)方法是Field類自己的方法，用於設置字段的值，而get(Object obj)則是獲取字段的值，固然關於Field類還有其餘經常使用的方法以下：

方法返回值	方法名稱	方法說明
void	set(Object obj, Object value)	將指定對象變量上此 Field 對象表示的字段設置爲指定的新值。
Object	get(Object obj)	返回指定對象上此 Field 表示的字段的值
Class<?>	getType()	返回一個 Class 對象，它標識了此Field 對象所表示字段的聲明類型。
boolean	isEnumConstant()	若是此字段表示枚舉類型的元素則返回 true；不然返回 false
String	toGenericString()	返回一個描述此 Field（包括其通常類型）的字符串
String	getName()	返回此 Field 對象表示的字段的名稱
Class<?>	getDeclaringClass()	返回表示類或接口的 Class 對象，該類或接口聲明由此 Field 對象表示的字段
void	setAccessible(boolean flag)	將此對象的 accessible 標誌設置爲指示的布爾值,即設置其可訪問性

上述方法多是較爲經常使用的，事實上在設置值的方法上，Field類還提供了專門針對基本數據類型的方法，如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法，這裏就不所有列出了，須要時查API文檔便可。須要特別注意的是被final關鍵字修飾的Field字段是安全的，在運行時能夠接收任何修改，但最終其實際值是不會發生改變的。

Method類及其用法

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

方法返回值	方法名稱	方法說明
Method	getDeclaredMethod(String name, Class<?>... parameterTypes)	返回一個指定參數的Method對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法。
Method[]	getDeclaredMethod()	返回 Method 對象的一個數組，這些對象反映此 Class 對象表示的類或接口聲明的全部方法，包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法。
Method	getMethod(String name, Class<?>... parameterTypes)	返回一個 Method 對象，它反映此 Class 對象所表示的類或接口的指定公共成員方法。
Method[]	getMethods()	返回一個包含某些 Method 對象的數組，這些對象反映此 Class 對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共 member 方法。

一樣經過案例演示上述方法：

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對象調用指定類的方法：

Class clazz = Class.forName("reflect.Circle");
//建立對象
Circle circle = (Circle) clazz.newInstance();

//獲取指定參數的方法對象Method
Method method = clazz.getMethod("draw",int.class,String.class);

//經過Method對象的invoke(Object obj,Object... args)方法調用
method.invoke(circle,15,"圈圈");

//對私有無參方法的操做
Method method1 = clazz.getDeclaredMethod("drawCircle");
//修改私有方法的訪問標識
method1.setAccessible(true);
method1.invoke(circle);

//對有返回值得方法操做
Method method2 =clazz.getDeclaredMethod("getAllCount");
Integer count = (Integer) method2.invoke(circle);
System.out.println("count:"+count);

/**
    輸出結果:
    draw 圈圈,count=15
    drawCircle
    count:100
*/
複製代碼

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

方法返回值	方法名稱	方法說明
Object	invoke(Object obj, Object... args)	對帶有指定參數的指定對象調用由此 Method 對象表示的底層方法。
Class<?>	getReturnType()	返回一個 Class 對象，該對象描述了此 Method 對象所表示的方法的正式返回類型,即方法的返回類型
Type	getGenericReturnType()	返回表示由此 Method 對象所表示方法的正式返回類型的 Type 對象，也是方法的返回類型。
Class<?>[]	getParameterTypes()	按照聲明順序返回 Class 對象的數組，這些對象描述了此 Method 對象所表示的方法的形參類型。即返回方法的參數類型組成的數組
Type[]	getGenericParameterTypes()	按照聲明順序返回 Type 對象的數組，這些對象描述了此 Method 對象所表示的方法的形參類型的，也是返回方法的參數類型
String	getName()	以 String 形式返回此 Method 對象表示的方法名稱，即返回方法的名稱
boolean	isVarArgs()	判斷方法是否帶可變參數，若是將此方法聲明爲帶有可變數量的參數，則返回 true；不然，返回 false。
String	toGenericString()	返回描述此 Method 的字符串，包括類型參數。

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

public interface Type {
    //1.8新增
    default String getTypeName() {
        return toString();
    }
}
複製代碼

而getParameterTypes/getGenericParameterTypes也是一樣的道理，都是獲取Method對象所表示的方法的參數類型，其餘方法與前面的Field和Constructor是相似的。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。