Java反射的使用入門詳解

1.什麼是反射

指程序可以訪問，檢測和修改它本身狀態或行爲的一種能力，並能根據自身行爲的狀態和結果，調整或修改應用所描述行爲的狀態和相關的語義。
反射是java中一種強大的工具，能夠使我們很方便的創建靈活的代碼，這些代碼可以再運行時裝配，無需在組件之間進行源代碼鏈接。但是反射使用不當會成本很高！

反射提供了一種機制——用來檢查可用的方法,並返回方法名.
人們想要在運行時獲取類的信息的另一動機,便是希望提供在跨網絡的遠程平臺上創建和運行類的能力.
                                        ——《Think In Java》第四版

反射用來幹什麼?

通過class文件對象:
1. 使用該文件的成員變量
2. 使用該文件的構造方法
3. 使用該文件的成員方法

1.用反射獲取class對象

//先準備一個Person類
package cn.lawfree_01;

public class Person {
    private String name;
    int age;
    public String address;
    //寫四種構造方式
    public Person() {}

    private Person(String name) {this.name = name;}

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void show() {
        System.out.println("show");
    }

    public void method(String s) {
        System.out.println("method " + s);
    }

    public String getString(String s, int i) {
        return s + "---" + i;
    }

    private void function() {
        System.out.println("function");
    }

    @Override
    public String toString() {
        return "姓名:" + name + "   年齡:" + age + "   地址:" + address;
    }

}

/*
 * 反射:就是通過class文件對象,去使用該文件的成員變量,構造方法
 * 
 * 通過class對象去幹其他事兒,首先就必須得到class文件獨享,其實也就是得到Class類的對象
 * (Class類:
 *      成員變量    Filed
 *      構造方法    Constructor
 *      成員方法    Method)
 * 
 * 獲取class對象的方式有三種:
 *  A:Object類的getClass()方法
 *  B:數據類型的靜態屬性class
 *  C:Class類中的靜態方法
 *      public static Class<?> forName(String className)
 * 
 * 一般選用哪一個?
 *      A:自己玩   任選一種,第二種比較方便
 *      B:開發    第三種
 *                  爲什麼?因爲第三種是一個字符串,而不是一個具體類名,這樣我們就可以把這樣的字符串配置到配置文件中
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式1:Object類的getClass()方法
        //先獲得一個示例對象的引用p
        Person p = new Person();
        //通過p.getClass獲得
        Class c = p.getClass();

        Person p2 = new Person();
        Class c2 = p.getClass();
        System.out.println(p == p2);// false//由於示例化了兩個對象,c和c2分別指向兩個不同的對象,這點很好理解
        System.out.println(c == c2);// true//注意這裏實際上獲得的同一個class對象(字節碼對象)`

        // 方式2,直接用類型名稱.class 來獲得
        Class c3 = Person.class;
        // int.class;
        // String.class;
        System.out.println(c == c3);//當然還是一樣的啦~

        // 方式3,Class.forName(類型的權限名)
        // ClassNotFpundException
        // cn.lawfree_01.Person
        Class c4 = Class.forName("cn.lawfree_01.Person");
        System.out.println(c == c4);//依然是一樣
    }
}

1.2通過反射獲取構造方法並使用

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 獲取字節碼文件對象
        Class c = Class.forName("cn.lawfree_01.Person"); // 好處就是:將來這裏配的是誰,運行的就是睡

        // 獲取構造方法(組)
        //1.使用getConstructors()獲得所有公共構造方法
        // public Constructor[] getConstructors()
        //2.使用getDeclaredConstructors()獲得所有構造方法
        // public Constructor[] getDeclaredConstructors()

        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        /*
         *private cn.lawfree_01.Person(java.lang.String)
         *cn.lawfree_01.Person(java.lang.String,int)
         *public cn.lawfree_01.Person(java.lang.String,int,java.lang.String)
         *public cn.lawfree_01.Person()
         *
         */

        // 獲取單個構造方法
        // public Constructor<T> getConstructor(Class<?>... parameterTypes)
        // 參數表示的是:你要獲取的構造方法的構造參數個數及數據類型的class字節碼文件對象.比如:
        Constructor con = c.getConstructor();// 返回的是構造方法對象

        // Person p=new Person();
        // System.out.println(p);
        // public T newInstance(Object... initargs)
        // 使用此 Constructor 對象表示的構造方法來創建該構造方法的聲明類的新實例，並用指定的初始化參數初始化該實例。
        Object obj = con.newInstance();//這樣構造哦!
        System.out.println(obj);
    }
}

把前面的結合運用一下:

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        // 獲取字節碼文件對象
        Class c = Class.forName("cn.lawfree_01.Person");

        // 獲取帶參構造器
        Constructor con = c.getConstructor(String.class, int.class,
                String.class);

        // 通過帶參構造方法創建對象
        // public T newInstance(Object... initargs)
        Object obj = con.newInstance("lawfree", 20, "成都");
        System.out.println(obj);//姓名:lawfree   年齡:21   地址:成都
    }
}

這裏再看一個例子:

import java.lang.reflect.Constructor;

/*
 * 需求:通過反射獲取私有構造方法並使用
 * private Person (String name)
 * Person p=new Person("lawfree");//這顯然是不行的
 * 
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        // 獲取字節碼對象
        Class c = Class.forName("cn.lawfree_01.Person");

        // 獲取私有構造方法
        // java.lang.NoSuchMethodException
        // Constructor con = c.getConstructor(String.class);// 這個方法只能拿public公共的

        Constructor con2 = c.getDeclaredConstructor(String.class);
        // java.lang.IllegalAccessException,非法的訪問異常
        // 暴力訪問
        con2.setAccessible(true);// 值爲 true 則指示反射的對象在使用時應該取消 Java 語言訪問檢查。。這樣就可以用getDeclaredConstructor(String.class)找到合適的構造方法

        // 用該私有方法創建對象
        Object obj = con2.newInstance("lawfree");

        System.out.println(obj);

    }
}

1.3通過反射獲得成員變量並使用

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 獲取字節碼文件對象
        Class c = Class.forName("cn.lawfree_01.Person");

        // 獲取所有成員變量
        // Field[] fields = c.getFields();還是隻能獲取公共的
        // Field[] fields = c.getDeclaredFields();
        // for (Field field : fields) {
        // System.out.println(field);
        // }

        /*
         *我們以前這樣做的:
         * Person p=new Person(); p.address="成都"; System.out.println(p);
         */

        // 通過無參構造創造對象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        // 獲取單個的成員變量並賦值
        Field addressField = c.getField("address");
        // public void set(Object obj, Object value)
        // 將制定對象變量上此Field對象表示的字段設置爲新值
        addressField.set(obj, "成都");// 給obj對象的addressField字段設置值爲爲"成都"
        System.out.println(obj);

        // 獲取name並對其賦值
        // java.lang.NoSuchFieldException(因爲他不是公共的)
        // Field nameField = c.getField("name");
        Field nameField = c.getDeclaredField("name");
        // java.lang.IllegalAccessException
        nameField.setAccessible(true);// 可以訪問
        nameField.set(obj, "lawfree");
        System.out.println(obj);

        // 獲取age並對其賦值
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj, 21);
        System.out.println(obj);
    }
}

1.3通過反射獲得成員方法並使用

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

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 獲取字節碼文件對象
        Class c = Class.forName("cn.lawfree_01.Person");

        // 獲取所有的方法
        // Method[] methods = c.getMethods();//獲取自己的包括父類的public方法
        // Method[] methods = c.getDeclaredMethods();//獲取自己的所有方法
        // for (Method method : methods) {
        // System.out.println(method);
        // }

        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        /*
         * 以前我們這麼用:
         * Person p=new Person(); p.show();
         */

        // 獲取單個方法並使用
        // public void show()
        // public Method getMethod(String name,Class<?>... parameterTypes)
        // 第一個參數表示方法名,第二個表示方法的class類型
        Method m1 = c.getMethod("show");
        // obj.m1();
        // public Object invoke(Object obj, Object... args
        // 返回值是Object,第一個數據表示對象是誰,第二個表示調用該方法的實際參數
        m1.invoke(obj);// 調用obj對象的,1方法

        System.out.println("------------");
        // public void method(String s)
        Method m2 = c.getDeclaredMethod("method", String.class);
        m2.invoke(obj, "hello");

        System.out.println("------------");
        // public String getString(String s, int i)
        Method m3 = c.getDeclaredMethod("getString", String.class, int.class);
        // Object objString = m3.invoke(obj, "hello", 100);
        // System.out.println(objString);
        String s = (String) m3.invoke(obj, "hello", 100);
        System.out.println(s);

        System.out.println("------------");
        // private void function()
        Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);

        //輸出結果:
        //      show
        //      ------------
        //      method hello
        //      ------------
        //      hello---100
        //      ------------
        //      function
    }
}