反射的概念

根據某個對象來獲取該對象所對應的類的完整信息。

反射的功能

1. 可以判斷運行時對象所屬的類；
2. 可以判斷運行時對象所包含的成員變量和方法。

Java 反射機制中的類

java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Modifier

類類型

在 Java 中，萬物皆對象，Object 類是所有類的父類，所有類的實例化對象都是 Class 類的對象，Class 類的對象稱為類類型。

獲取一個類的類類型的方法

首先，我們有一個 Person 類，如下：

package reflecttest;

public class Person {
    
    // 定義 private 修飾的成員變量
    private String name;
    private int age;
    
    // 定義一個無參構造方法
    public Person() {
        
    }

    // 定義一個 public 修飾的帶參數構造方法
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // get set 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    // 重寫 toString() 方法
    @Override
    public String toString() {
        return name + ", " + age;
    }
    
}

1. 對象.getClass()

任何一個類都繼承了 Object 類，因此也繼承了 getClass() 方法，通過該類的對象調用 getClass() 方法可以得到該類的類類型。

public class Test01 {
    
    public static void main(String[] args) {

        Person p = new Person();
        Class c1 = p.getClass();
        // 取得類名
        System.out.println(c1);
        // 取得包名
        System.out.println(c1.getName());

    }
    
}

運行結果：

2. 類名.class

每個類中都隱含了一個靜態屬性 class，通過 類名.class，也可以獲得該類的類類型。

public class Test01 {
    
    public static void main(String[] args) {
        
        Class c2 = Person.class;
        // 取得類名
        System.out.println(c2);
        // 取得包名
        System.out.println(c2.getName());
        
    }
    
}

運行結果：

3. Class.forName

通過動態加載類，Class.forName(“類名的全稱(包含包名)”)，Class.forName 必須拋出異常或對異常進行捕獲處理。

public class Test01 {
    
    public static void main(String[] args) {
        
        try {
            Class c3 = Class.forName("reflecttest.Person");
            // 取得類名
            System.out.println(c3);
            // 取得包名
            System.out.println(c3.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
    
}

運行結果：

注： 靜態加載，在編譯時加載的類稱為靜態加載類；動態加載，在運行時加載的類稱為動態加載類。

通過一個類的類類型獲取該類的詳細信息

獲得一個類的類類型后，可以創建該類對象，并且反射出該類中的方法和屬性。

1. 通過類類型創建對象

public class Test02 {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        
            Person p1 = new Person();
            Class c1 = p1.getClass();
            Person p2 = (Person) c1.newInstance();
            
            Class c2 = Person.class;
            Person p3 = (Person) c2.newInstance();
            
            Class c3 = Class.forName("reflecttest.Person");
            Person p4 = (Person) c3.newInstance();
            
            // 得到類類型所代表的類名的全稱，包含包名
            System.out.println(c3.getName());
            // 得到類類型所代表的類名，不包含類名
            System.out.println(c3.getSimpleName());
        
    }

}

運行結果：

注意： 通過類類型創建對象時，該類必須要有無參的構造方法。

2. 通過類類型反射出該類中所有的屬性

在 Java 中，萬物皆對象，屬性也是對象，它是 Feild 類的對象。

通過類類型反射出該類中所有的方法

在 Java 中，萬物皆對象，方法也是對象，它是 Method 類的對象。

通過類類型反射出該類的所有構造方法

在 Java 中，萬物皆對象，構造方法也是對象，它是 Constructor 類的對象。

參考資料：

• JAVA中的反射機制 - 劉佳翰
• java中的反射總結 - Nerxious