Java核心技術點之反射

時間 2019-12-07

標籤 java 核心技術反射欄目 Java 简体版

原文原文鏈接

1. 概述java

Java 反射是可讓咱們在運行時獲取類的方法、屬性、父類、接口等類的內部信息的機制。也就是說，反射本質上是一個「反着來」的過程。咱們經過new建立一個類的實例時，其實是由Java虛擬機根據這個類的Class對象在運行時構建出來的，而反射是經過一個類的Class對象來獲取它的定義信息，從而咱們能夠訪問到它的屬性、方法，知道這個類的父類、實現了哪些接口等信息。數組

2. Class類函數

咱們知道使用javac可以將.java文件編譯爲.class文件，這個.class文件包含了咱們對類的原始定義信息（父類、接口、構造器、屬性、方法等）。.class文件在運行時會被ClassLoader加載到Java虛擬機（JVM）中，當一個.class文件被加載後，JVM會爲之生成一個Class對象，咱們在程序中經過new實例化的對象其實是在運行時根據相應的Class對象構造出來的。確切的說，這個Class對象其實是java.lang.Class<T>泛型類的一個實例，好比Class<MyClass>對象即爲一個封裝了MyClass類的定義信息的Class<T>實例。因爲java.lang.Class<T>類不存在公有構造器，所以咱們不能直接實例化這個類，咱們能夠經過如下方法獲取一個Class對象。this

在下面的講解中，咱們將以People類和Student類爲例：spa

 1 public class People {
 2     private String name;
 3     private int age;
 4     
 5     public People(String name, int age) {
 6         this.name = name;
 7         this.age = age;
 8     }
 9     
10     public int getAge() {
11         return age;
12     }
13 
14     public String getName() {
15         return name;
16     }
17 
18     public void setAge(int age) {
19         this.age = age;
20     }
21 
22     public void setName(String name) {
23         this.name = name;
24     }
25     
26     public void speak() {
27         System.out.println(getName() + " " + getAge());
28     }
29 }

 1 public class Student extends People {
 2     private int grade;
 3     
 4     public Student(String name, int age) {
 5         super(name, age);
 6     }
 7     
 8     public Student(String name, int age, int grade) {
 9         super(name, age);
10         this.grade = grade;
11     }
12     
13     public int getGrade() {
14         return grade;
15     }
16 
17     public void setGrade(int grade) {
18         this.grade = grade;
19     }
20   
21     private void learn(String course) {
22         System.out.println(name + " learn " + course);
23     }
24  }

（1）經過類名獲取Class對象：code

若在編譯期知道一個類的名字，咱們能夠這樣獲取它的Class對象：對象

1 Class<People> peopleClass = People.class;

還有一種根據類的完整路徑名獲取Class對象的方法以下所示：blog

1 Class<People> peopleClass = Class.forName("com.test.People"); //假設People類在com.test包中

注意，Class.forName()方法的參數必須是一個類的全路徑名。實際上，只要咱們「import com.test.People"，就能夠直接經過」People.class"獲取他的Class對象，而不用寫出全路徑這麼麻煩。
（若在調用 Class.forName()方法時，沒有在classpath找到對應的類，會拋出 ClassNotFoundException。）繼承

（2）經過對象自己獲取其Class對象：接口

1 People people = new People("Bill"， 18);
2 Class<People> peopleClass = people.getClass();

3. 經過反射獲取類的構造器

一旦咱們得到了People的Class 對象，咱們即可以經過這個Class 對象獲取到People類的原始定義信息。首先，咱們來獲取People類的構造器對象，有了這個構造器對象，咱們便可以構造出一個People對象出來。好比，咱們能夠在Student.java中添加如下代碼：

 1 public static void main(String[] args) {
 2         Class<People> pClass = People.class;
 3         System.out.println(pClass);
 4         try {
 5             Constructor<People> constructor = pClass.getConstructor(String.class, int.class);
 6             People people = constructor.newInstance("Bill", 18);
 7             obj.speak();
 8         } catch (Exception e) {
 9             e.printStackTrace();
10         }
11 }

在第4行，咱們調用getConstructor方法來獲取一個People類的構造器對象，因爲咱們想要獲取的構造器的形參類型爲String和int，因此咱們傳入String.class和int.class。有了構造器對象，咱們即可以調用newInstance方法來建立一個people對象，如上面代碼的第6行所示。

注意，當經過反射獲取到類的 Constructor、Method、Field對象後，在調用這些對象的方法以前，先將此對象的 accessible 標誌設置爲 true，以取消 Java 語言訪問檢查，能夠提高反射速度。如如下代碼所示：

1 Constructor<People> constructor = peopleClass.getConstructor(String.class， int.class);
2 // 設置 constructor 的 Accessible屬性爲ture以取消Java的訪問檢查
3 constructor.setAccessible(true);

4. 經過反射獲取類中定義的方法

（1）獲取當前類中定義的方法（不包括從父類繼承來的）

要獲取當前類中定義的全部方法能夠經過 Class 中的 getDeclaredMethods 函數，它會獲取到當前類中定義的全部方法（包括private、public、static等各類方法），它會返回一個Method對象數組，其中的每一個Method對象即表示了一個類中定義的方法。要想得到指定的方法，能夠調用getDeclaredMethod(String name, Class...<T> parameterTypes)。如如下代碼所示 :

 1 private static void showDeclaredMethods() {
 2         Student student = new Student("Bill", 18);
 3         Method[] methods = student.getClass().getDeclaredMethods();
 4         for (Method method : methods) {
 5             System.out.println("declared method name : " + method.getName());
 6         }
 7 
 8         try {
 9             //獲取learnMethod對象（封裝了learn方法）
10             Method learnMethod = student.getClass().getDeclaredMethod("learn", String.class);
11             //獲取learn方法的參數列表並打印出來
12             Class<?>[] paramClasses = learnMethod.getParameterTypes() ;
13             for (Class<?> class : paramClasses) {
14                 System.out.println("learn方法的參數: " + class.getName());
15             }
16             //判斷learn方法是否爲private
17             System.out.println(learnMethod.getName() + " is private "
18                     + Modifier.isPrivate(learnMethod.getModifiers()));
19             learnMethod.invoke(student, "Java Reflection");
20         } catch (Exception e) {
21             e.printStackTrace();
22         }
23     }

第12行，經過調用Method對象的getParameterTypes方法來獲取一個方法的形參的類型列表，這個方法會返回一個Class<T>數組。好比因爲learn方法只有一個String類型的參數，因此調用此方法會返回一個只包含String.class一個元素的Class<T>數組。（因爲返回的Class對象分別對應了不一樣類型，因此咱們在上面的代碼中用了Class<?>。）

第14行，咱們調用了Class對象的getName方法，這個方法會返回這個Class對象所封裝的類的全名（本例中會返回java.lang.String)。

第19行，經過調用Method對象的invoke方法能夠調用相應Method對象所封裝的方法。

（2）獲取當前類和父類中定義的公有方法

要獲取當前類以及父類中的全部 public 方法能夠調用getMethods 函數，而要獲取某個指定的public方法，能夠調用getMethod方法。請看如下代碼：

 1 private static void showMethods() {
 2         Student student = new Student("mr.simple");
 3         // 獲取全部public方法(包括Student自己的和從父類繼承來的）
 4         Method[] methods = student.getClass().getMethods();
 5         for (Method method : methods) {
 6             System.out.println("method name : " + method.getName());
 7         }
 8         try {
 9             //注意，經過 getMethod只能獲取public方法，若嘗試獲取private方法則會拋出異常
10             Method learnMethod = student.getClass().getMethod("learn", String.class);
11           
12         } catch (Exception e) {
13             e.printStackTrace();
14         }
15     }

5. 經過反射獲取類中定義的屬性

獲取屬性與獲取方法是相似的，只不過 getMethod 函數換成了 getField，getDeclaredMethod 換成了 getDeclaredField 。

（1）獲取當前類中定義的屬性（不包括從父類繼承來的屬性）

要獲取當前類中定義的全部屬性（包括private、public、static等各類屬性）能夠調用 Class對象的getDeclaredFields函數；要想得到指定的屬性，能夠調用getDeclaredField。如如下代碼所示

 1  private static void showDeclaredFields() {
 2         Student student = new Student("Bill", 18);
 3         // 獲取當前類中定義的全部屬性並顯示出來
 4         Field[] fields = student.getClass().getDeclaredFields();
 5         for (Field field : publicFields) {
 6             System.out.println("declared field name : " + field.getName());
 7         }
 8 
 9         try {
10             // 獲取指定的屬性
11             Field gradeField = student.getClass().getDeclaredField("grade");
12             // 獲取屬性值
13             System.out.println("The grade is : " + gradeField.getInt(student));
14             // 設置屬性值
15             gradeField.set(student, 10);
16             System.out.println("The grade is : " + gradeField.getInt(student));
17         } catch (Exception e) {
18             e.printStackTrace();
19         }
20 }

（2）獲取當前類和父類中定義的public屬性

要獲取當前類和父類中定義的全部public 屬性能夠調用Class對象的getFields 函數，而要獲取某個指定的public屬性，能夠調用getField方法，如如下代碼所示：

private static void showFields() {
        Student student = new Student("Bill"， 18);
        // 獲取當前類和父類的全部public屬性並顯示
        Field[] publicFields = student.getClass().getFields();
        for (Field field : publicFields) {
            System.out.println("field name : " + field.getName());
        }
}

6. 經過反射獲取類的父類及類所實現的接口

（1）獲取父類

調用Class對象的getSuperClass方法便可，如如下代碼所示：

1 Student student = new Student("Bill", 18);
2 Class<?> superClass = student.getClass().getSuperclass();
3 System.out.println("Student's super class is : " + superClass.getName());

(2) 獲取接口

要知道一個類實現了哪些接口，只需調用Class對象的getInterfaces方法，如如下代碼所示：

1 private static void showInterfaces() {
2         Student student = new Student("Bill", 19);
3         Class<?>[] interfaces = student.getClass().getInterfaces();
4         for (Class<?> interface : interfaces) {
5                 System.out.println("Implements interface: " + interface.getName());
6         }
7 }

因爲Student類未顯式實現任何接口，因此以上代碼什麼也不會輸出。