Java反射，獲取類的公有、私有的構造函數（有參，無參）、方法（有參，無參）、屬性

    Class類與java.lang.reflect類庫一起對反射進行了支持，該類庫包含Field、Method和Constructor類，這些類的對象由JVM在啟動時創建，用以表示未知類里對應的成員。這樣的話就可以使用Contructor創建新的對象，用get()和set()方法獲取和修改類中與Field對象關聯的字段，用invoke()方法調用與Method對象關聯的方法。另外，還可以調用getFields()、getMethods()和getConstructors()等許多便利的方法，以返回表示字段、方法、以及構造器對象的數組，這樣，對象信息可以在運行時被完全確定下來，而在編譯時不需要知道關於類的任何事情。

    首先創建一個類

public class Per {
     public String name="sunshine";
     private int age=28;
     public double weight=65.50;
     
     public Per(){
         System.out.println("測試反射獲取公有無參構造函數");
     }
     private Per(String name){
         this.name=name;
         System.out.println("測試反射獲取私有有參構造函數");
     }
     public Per(String name,int age){
         this.name=name;
         this.age=age;
         System.out.println("測試反射獲取公有有多個參數構造函數name:"+name+"    age:"+age);17      }
     public String methodT1(){
         System.out.println("測試反射獲取公有無參方法");
         return null;
     }
     public String methodT1(String name,int age){
         System.out.println("測試反射獲取公有多個參方法");
         System.out.println(name+"："+age);
         return null;
     }
     private String methodT1(String name){
         System.out.println("測試反射獲取私有有參方法");
         System.out.println("name:"+name);
         return null;
     }
     public String methodT2(int[] arr,String[] str){
         System.out.println("測試反射獲取公有有數組參方法");
         System.out.println("int[] arr:"+arr+"String[] str:"+str);
         return null;
     }
     public static void main(String[] args) {
        System.out.println("測試反射獲取main方法");
    }
}

 

    1.使用java反射獲取類的構造函數（公有、私有）（有參，無參）

 

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
/**
 * 測試使用java反射獲取類的構造函數並創建對象
 * @author Sunshine
 *
 */
public class ReflectPer {
    private static Class class1;
    //因為java反射獲取類時都需要加載類，在這里我就使用Junit的@beforeclass來去加載類，不用在每個測試方法中重復創建
    //注：@beforeclass在執行測試方法前運行
    @BeforeClass
    public static void beforeClass() throws Exception{
        System.out.println("====測試方法啟動前先加載類====");
        class1 = Class.forName("myPractise.Per");//加載類
    }
    //獲取類的公有無參構造函數,並創建對象
    @Test
    public void test1() throws Exception{
        Constructor constructor = class1.getConstructor(null);//獲取公有無參構造器，值為null代表獲取無參構造器
        Per per = (Per) constructor.newInstance(null);//創建對象，返回的是Object類型要強轉
        System.out.println(per.name);//可以調用類的屬性-----成功
    }
    //獲取類的公有參構造函數,並創建對象
    @Test
    public void test2()throws Exception{
        Constructor constructor = class1.getConstructor(String.class,int.class);//獲取公有多個參數構造器，參數為構造器中參數的類型
        Per per = (Per)constructor.newInstance("baby",24);//創建對象
    }
    //獲取類的私有有參構造函數,並創建對象
    @Test
    public void test3()throws Exception{
        Constructor constructor = class1.getDeclaredConstructor(String.class);//獲取公有多個參數構造器，參數為構造器中參數的類型
        constructor.setAccessible(true);//暴力反射，只有將屬性設置為true才可以創建對象
        Per per = (Per)constructor.newInstance("baby");
        System.out.println(per.weight);//可以調用類的屬性-----成功
        //注：通常情況下一個類不可以訪問另一個類的私有的屬性，方法。。但是通過java反射可以
    }
    @AfterClass
    public static void afterClass(){
        System.out.println("===測試完成將對象賦值為null===");
    }
}

   2.使用java反射獲取類的方法（公有、私有）（有參，無參）

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
/**
 * 測試使用java反射獲取類方法
 * @author Sunshine
 *
 */
public class ReflectPer {
    private static Class class1;
    private static Per per;
    //因為java反射獲取類時都需要加載類，在這里我就使用Junit的@beforeclass來去加載類，不用在每個方法中重復創建
    //注：@beforeclass在執行測試方法前運行
    @BeforeClass
    public static void beforeClass() throws Exception{
        System.out.println("====測試方法啟動前先加載類====");
        class1 = Class.forName("myPractise.Per");//加載類
        per = (Per) class1.getConstructor(null).newInstance(null);//使用反射創建對象
    }
    
    //獲取類的公有無參方法
    @Test
    public void test4()throws Exception{
        Method method = class1.getMethod("methodT1", null);//獲取指定的方法，參數為方法名和該方法的參數類型，因為我們這是測試無參的方法，所以傳入null
        method.invoke(per, null);//使用invoke方法來調用,參數為指定對象，該方法傳入的參數，因為我們這是測試無參的方法，所以傳入null
    }
    //獲取類的公有有參方法
    @Test
    public void test5()throws Exception{
        Method method = class1.getMethod("methodT1", String.class,int.class);//獲取指定的方法，參數為方法名和該方法的參數類型
        method.invoke(per, "sunshine",25);//使用invoke方法來調用,參數為指定對象，該方法傳入的參數
    }
    @Test
    public void test6()throws Exception{
        Method method = class1.getDeclaredMethod("methodT1", String.class);//獲取指定的方法，參數為方法名和該方法的參數類型
        method.setAccessible(true);//暴力反射，默認為false，未設置則調用類的私有方法不成功
        method.invoke(per, "sunshine");//使用invoke方法來調用,參數為指定對象，該方法傳入的參數
        System.out.println(method.getReturnType());//獲取到該類指定方法的返回值類型
    }
    @Test
    public void test7()throws Exception{
        Method method = class1.getMethod("methodT2", int[].class,String[].class);
        method.invoke(per, new int[]{1,2},new String[]{"AA","BB"});
    }
    //獲取某個類的main方法比較特殊也可以說是只要傳入的參數為單個數組特殊
    //jdk5之后新增特性--可變參數
    //在加載時會將傳入的數組進行拆分，這樣就會報錯，java.lang.IllegalArgumentException: wrong number of arguments 錯誤的參數個數
    //這時候我們可以欺騙一下虛擬機，告訴他我們傳入的是一個對象將new String[]{"AA","BB"}換成(Object)new String[]{"AA","BB"}
    @Test
    public void test8()throws Exception{
        Method method = class1.getMethod("main",String[].class);
        method.invoke(per,(Object)new String[]{"AA","BB"});
    }
    @AfterClass
    public static void afterClass(){
        System.out.println("===測試完成將對象賦值為null===");
    }
}

 

3.使用java反射獲取類的屬性（公有、私有）

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * 測試使用java反射獲取類的屬性
 * 
 * @author Sunshine
 *
 */
public class ReflectPer {
    private static Class class1;
    private static Per per;

    // 因為java反射獲取類時都需要加載類，在這里我就使用Junit的@beforeclass來去加載類，不用在每個測試方法中重復創建
    // 注：@beforeclass在執行測試方法前運行
    @BeforeClass
    public static void beforeClass() throws Exception {
        System.out.println("====測試方法啟動前先加載類====");
        class1 = Class.forName("myPractise.Per");// 加載類
        per = (Per) class1.getConstructor(null).newInstance(null);// 使用反射創建對象
    }
    // 公有屬性
    @Test
    public void test9() throws Exception {
        // 獲取某個屬性，參數是屬性名
        Field field = class1.getField("name");
        // 輸出屬性值，需要傳入指定對象
        System.out.println(field.get(per));
        // 獲取屬性的類型
        System.out.println(field.getType());
        // 獲取多個屬性
        Field[] field1 = class1.getFields();
        // 增強for循環Jdk1.5后的新特性，只適用於數組和實現了Iterator的集合
        for (Field str : field1) {
            System.out.println(str);
        }
        // 設置屬性值
        field.set(per, "baby");
        System.out.println(field.get(per));
    }
    //私有屬性
    @Test
    public void test10() throws Exception {
        Field field = class1.getDeclaredField("age");
        field.setAccessible(true);//暴力反射
        System.out.println(field.get(per));
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("===測試完成將對象賦值為null===");
    }
}