Java中的反射機制

　　Android開發中的熱修復涉及到反射及類的加載等，因此先回顧一下java的反射，關於反射的定義及作用等引用博客“https://www.cnblogs.com/Eason-S/p/5851078.html”中的話。

　　說明：上述鏈接的標題四中的第【8】條描述有誤，已經在留言中指出，詳情也可查看本文“反射的例子”的標注說明。

一、Java反射機制：
    　　主要是指程序可以訪問，檢測和修改它本身狀態或行為的一種能力，並能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。在java中，只要【給定類的名字】， 那么就可以通過反射機制來獲得類的所有信息。   

二、作用：
1、在運行時判斷任意一個對象所屬的類；
2、在運行時獲取類的對象；
3、在運行時訪問java對象的屬性，方法，構造方法等。

三、優缺點：
優點：
1、可以實現動態創建對象和編譯，體現出很大的靈活性。
2、對於JAVA這種先編譯再運行的語言來說，反射機制可以使代碼更加靈活，更加容易實現面向對象。

缺點：
1、對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么並且它滿足我們的要求。這類操作總是慢於只直接執行相同的操作。

四、反射的應用場景：

1、該類的某個方法是在高版本新增的，例如MediaRecorder.java在Android6.0以后新增了resume()方法用於暫停后的再次錄制，此時項目為了兼容低版本則可以判斷當版本>=6.0時調用該
方法，但是為了能在6.0以下的開發環境中編譯通過，可以使用反射調用該方法。----------僅作為例子說明，實際開發中編譯環境一般都會超過6.0。

2、關於Handler機制中消息的同步分隔欄，需要通過postSyncBarrier()設置：該方法屬於隱藏方法hide在API23之前，該方法需要通過Looper調用；從API23開始，源碼去掉了Looper中的方法，此時只能通過MessageQueue調用；但無論上述哪種，都需要通過反射調用；

例如：MessageQueue類只有帶參的構造函數，因此需要先getDeclaredConstructor(),然后再創建實例。

//方式一：
            Class<?> looperCls = Class.forName("android.os.MessageQueue");
            Constructor<?>  constructor = looperCls.getDeclaredConstructor(boolean.class);
            constructor.setAccessible(true);        //設置可訪問
            
            Method method = looperCls.getMethod("postSyncBarrier");
            method.invoke(constructor.newInstance(true));  //根據帶參的構造函數創建實例並調用

postSyncBarrier函數
            

//方式二：
            Looper looper = getMainLooper();
            MessageQueue queue = looper.getQueue();
            Method  methodSync = queue.getClass().getMethod("postSyncBarrier");
            methodSync.invoke(queue);

 

五、反射的例子

package com.test.pattern;

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

public class TestReflect extends Object{

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            Class<?> mClass = Class.forName("com.test.pattern.Child");
            
            Field[] childFields = mClass.getDeclaredFields();
            
            System.out.println("---------mClass.getDeclaredFields():--------- ");
            
            for (Field field : childFields) {
                int mod = field.getModifiers();  
                Class<?> type = field.getType();
                String name = field.getName();
                
                System.out.println(mod + "  name: " + name + "  type: " + type);
            }
            
            System.out.println("\n--------- mClass.getFields(): ---------");
            
            Field[] fields = mClass.getFields();   //注意點
            
            for (Field field : fields) {
                int mod = field.getModifiers();  
                Class<?> type = field.getType();
                String name = field.getName();
                
                System.out.println(mod + "  name: " + name + "  type: " + type);
            }
            
            System.out.println("\n--------- mClass.getDeclaredMethods()---------");
            
            Method[] methods = mClass.getDeclaredMethods();
            for (Method method : methods) {
                try {
                    
                    if("childMethod".equals(method.getName())){
                        method.setAccessible(true);   //設置可訪問-------
                        Constructor<?>  constructor = mClass.getDeclaredConstructor(String.class);
                        Object obj = method.invoke(constructor.newInstance("use_in_reflect"));
                        System.out.println("obj: " + obj);
                    }
                    
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
    
    
}


interface Parent{
    //public static final
    String pName = "inter";
    
    void methodInter();
}

class Child implements Parent{
    
    private String cName = "childName";
    
    public String pro = "pro";        //注意點
    
    String def = "default";
    
    public int count = 10;            //注意點
    
    Child(String name) {
        // TODO Auto-generated constructor stub
        this.cName = name ;
    }
    

    @Override
    public void methodInter() {
        // TODO Auto-generated method stub
        System.out.println("print_pName: " + pName);
    }
    
    private String childMethod(){
        String m = "method_of_child " + cName;
        return m;
    }
    
}


//運行結果：
/*

---------mClass.getDeclaredFields():--------- 
2  name: cName  type: class java.lang.String
1  name: pro  type: class java.lang.String
0  name: def  type: class java.lang.String
1  name: count  type: int

--------- mClass.getFields(): ---------//注意點
1  name: pro  type: class java.lang.String
1  name: count  type: int
25  name: pName  type: class java.lang.String

--------- mClass.getDeclaredMethods()---------
obj: method_of_child use_in_reflect

*/

重點說明一下方法getFields()：獲取公有屬性，即獲取的不僅僅是父類屬性，還包括類本身public類型的屬性。看“注意點”的運行結果即可知道。

官方介紹：
    /* Returns an array containing {@code Field} objects reflecting all
     * the accessible public fields of the class or interface represented by
     * this {@code Class} object.
     */

六、參考文章：

1、https://blog.csdn.net/qq_38371934/article/details/81071881

2、https://www.cnblogs.com/Eason-S/p/5851078.html