2. 程式人生 > >理解Java反射

理解Java反射

阿新 • • 發佈：2018-12-08

反射簡介

Java讓我們在執行時識別物件和類的資訊，主要有2種方式：一種是傳統的RTTI，它假定我們在編譯時已經知道了所有的型別資訊；另一種是反射機制，它允許我們在執行時發現和使用類的資訊。
JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這種動態獲取的資訊以及動態呼叫物件的方法的功能稱為java語言的反射機制。
想解剖一個類,必須先要獲取到該類的位元組碼檔案物件。而解剖使用的就是Class類中的方法.所以先要獲取到每一個位元組碼檔案對應的Class型別的物件
反射就是動態的從記憶體載入一個指定的類，把java類中的各種成分對映成一個個的Java物件，獲取該類中的所有的內容。

反射的功能

1.在執行時判斷任意一個物件所屬的類；
2.在執行時構造任意一個類的物件；
3.在執行時判斷任意一個類所具有的成員變數和方法（通過反射甚至可以呼叫private方法）；
4.在執行時呼叫任意一個物件的方法
重點：是執行時而不是編譯時
反射的優點：增加程式的靈活性；增強了程式的擴充套件性。
反射的缺點：運用反射會使我們的軟體的效能降低，複雜度增加。

反射的使用

獲取Class物件

1：通過每個物件都具備的方法getClass來獲取。弊端：必須要建立該類物件，才可以呼叫getClass方法。
2：每一個數據型別(基本資料型別和引用資料型別)都有一個靜態的屬性class。弊端：必須要先明確該類。
　　前兩種方式不利於程式的擴充套件，因為都需要在程式使用具體的類來完成。
3：使用的Class類中的方法，靜態的forName方法。指定什麼類名，就獲取什麼類位元組碼檔案物件，這種方式的擴充套件性最強，只要將類名的字串傳入即可。
示例程式碼如下：

package com.luis.test;
public class User {
    private long id;
    private String name;
    public int age;
    
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    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;
    }
    
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

public class GetClass {
    public static void main(String[] args) {
        //1、通過物件呼叫 getClass() 方法來獲取,通常應用在：比如你傳過來一個 Object
        //  型別的物件，而我不知道你具體是什麼類，用這種方法
        User user = new User();
        Class c1 = user.getClass();
            
        //2、直接通過 類名.class 的方式得到,該方法最為安全可靠，程式效能更高
        //  這說明任何一個類都有一個隱含的靜態成員變數 class
        Class c2 = User.class;
            
        //3、通過 Class 物件的 forName() 靜態方法來獲取，用的最多，
        //丟擲 ClassNotFoundException 異常
        Class c3;
        try {
            c3 = Class.forName("com.luis.test.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

獲取類中的方法，屬性，建構函式。

public class GetClass {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("com.luis.test.User");
            Constructor con = clazz.getConstructor(new Class[]{});
            User instance = (User) con.newInstance();
            instance.toString();
            //獲得類完整的名字
            String className = clazz.getName();
            System.out.println("---------完整類名----------");
            System.out.println(className);
                    
            //獲得類的public型別的屬性。
            Field[] fields = clazz.getFields();
            System.out.println("---------public屬性----------");
            for(Field field : fields){
               System.out.println("public類:"+field.getName());
            }
                    
            //獲得類的所有屬性包括私有的
            Field [] allFields = clazz.getDeclaredFields();
            System.out.println("---------所有屬性----------");
            for(Field field : allFields){
                System.out.println(field.getName());
            }
                    
            //獲得類的public型別的方法。這裡包括 Object 類的一些方法
            Method [] methods = clazz.getMethods();
            System.out.println("---------public方法----------");
            for(Method method : methods){
                System.out.println(method.getName());
            }
                    
            //獲得類的所有方法。
            Method [] allMethods = clazz.getDeclaredMethods();
            System.out.println("---------所有方法----------");
            for(Method method : allMethods){
                System.out.println(method.getName());
            }
                    
            //獲得指定的屬性
            Field f1 = clazz.getField("age");
            System.out.println("---------指定屬性----------");
            System.out.println(f1);
            //獲得指定的私有屬性
            System.out.println("---------指定私有屬性----------");
            Field f2 = clazz.getDeclaredField("name");
            //啟用和禁用訪問安全檢查的開關，值為 true，則表示反射的物件在使用時應該取消 java 語言的訪問檢查；反之不取消
            f2.setAccessible(true);
            System.out.println(f2);
                            
            //建立這個類的一個物件
            Object p2 =  clazz.newInstance();
            //將 p2 物件的  f2 屬性賦值為 Bob，f2 屬性即為 私有屬性 name
            f2.set(p2,"luis");
            //使用反射機制可以打破封裝性，導致了java物件的屬性不安全。 
            System.out.println("---------建立物件----------");
            System.out.println(f2.get(p2)); //Bob
                    
            //獲取構造方法
            Constructor [] constructors = clazz.getConstructors();
            System.out.println("---------獲取構造方法----------");
            for(Constructor constructor : constructors){
                System.out.println(constructor.toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

執行結果：

---------完整類名----------
com.luis.test.User
---------public屬性----------
public類:age
---------所有屬性----------
id
name
age
---------public方法----------
toString
getName
getId
setName
getAge
setId
setAge
wait
wait
wait
equals
hashCode
getClass
notify
notifyAll
---------所有方法----------
toString
getName
getId
setName
getAge
setId
setAge
---------指定屬性----------
public int com.luis.test.User.age
---------指定私有屬性----------
private java.lang.String com.luis.test.User.name
---------建立物件----------
luis
---------獲取構造方法----------
public com.luis.test.User()

反射獲取父類屬性

可以通過反射獲取父類的私有屬性，程式碼如下：

public class Parent {
    public String publicField = "parent_publicField";
    protected String protectField = "parent_protectField";
    String defaultField = "parent_defaultField";
    private String privateField = "parent_privateField";
}

package com.luis.test;
public class Admin extends Parent{
}

public class GetClass {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("com.luis.test.Admin");
            //獲取父類私有屬性值
            System.out.println(getFieldValue(clazz.newInstance(),"privateField"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Field getDeclaredField(Object obj,String fieldName) {
        Field field = null;
        Class c = obj.getClass();
             for(; c != Object.class ; c = c.getSuperclass()){
                 try {
                     field = c.getDeclaredField(fieldName);
                     field.setAccessible(true);
                     return field;
                 }catch (Exception e){
                     //如果這裡的異常列印或者往外拋，則就不會執行c = c.getSuperclass(),最後就不會進入到父類中了
                 }
             }
        return null;
    }
    public static Object getFieldValue(Object object,String fieldName) throws Exception{
          Field field = getDeclaredField(object,fieldName);
          return field.get(object);
    }
}

執行結果：parent_privateField
要注意：直接通過反射獲取子類的物件是不能得到父類的屬性值的，必須根據反射獲得的子類 Class 物件在呼叫 getSuperclass() 方法獲取父類物件，然後在通過父類物件去獲取父類的屬性值。

動態代理

代理類在程式執行時建立的代理方式被成為動態代理。代理類並不是在Java程式碼中定義的，而是在執行時根據我們在Java程式碼中的“指示”動態生成的。相比於靜態代理， 動態代理的優勢在於可以很方便的對代理類的函式進行統一的處理，而不用修改每個代理類中的方法。
介面和實現類：

public interface Interface {
    void doSomething();
    void somethingElse(String arg);
}

public class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("doSomething.");
    }

    @Override
    public void somethingElse(String arg) {
         System.out.println("somethingElse " + arg);
    }
}

動態代理物件處理器：

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxyed;

    public DynamicProxyHandler(Object proxyed) {
        this.proxyed = proxyed;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("代理工作了.");
         return method.invoke(proxyed, args);
    }
}

測試類：

public class Main {
    public static void main(String[] args) {
        RealObject real = new RealObject();
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[] {Interface.class},new DynamicProxyHandler(real));
        proxy.doSomething();
        proxy.somethingElse("luis");
    }
}

反射極大地增強了程式碼的靈活性，廣泛應用於各種框架中，因而對於反射的掌握是非常重要的。

本文參考了：
https://www.cnblogs.com/ysocean/p/6516248.html
https://www.cnblogs.com/luoxn28/p/5686794.html
https://blog.csdn.net/ShadowySpirits/article/details/79756259

相關推薦

如何理解java反射？

stat 過程 最大 inter pack -m 向下轉型 hibernate con 一、反射基本概念 反射之中包含了一個“反”的概念，所以要想解釋反射就必須先從“正”開始解釋，一般而言，當用戶使用一個類的時候，應該先知道這個類，而後通過這個類產生實例化對象，但是“反”指

理解Java反射機制

ext 就是 概念 alt target private 一個 反射機制 語言 　　看了知乎老頑童周伯通的回復和深入解析java反射關於反射的講解，終於對反射的概念有了新的認識。不再畫蛇添足了，轉載一下精華部分。 一、為什麽要用到反射？ 假如你寫了一段代碼：Objec

深入理解Java反射

override nts 準備工作 class red declare hand 類型信息 屬於 　　要想理解反射的原理，首先要了解什麽是類型信息。Java讓我們在運行時識別對象和類的信息，主要有2種方式：一種是傳統的RTTI，它假定我們在編譯時已經知道了所有的類型信息；另

理解Java反射

反射簡介 Java讓我們在執行時識別物件和類的資訊，主要有2種方式：一種是傳統的RTTI，它假定我們在編譯時已經知道了所有的型別資訊；另一種是反射機制，它允許我們在執行時發現和使用類的資訊。 JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任

深入理解java反射原理

　　反射是java的一個特性，這一特性也使得它給了廣大的第三方框架和開發過者很大的想像空間。 　　通過反射，java可以動態的載入未知的外部配置物件，臨時生成位元組碼進行載入使用，從而使程式碼更靈活！可以極大地提高應用的擴充套件性！ 　　但是，除了停留在使用其華麗功能，我們還可以去看看其實現！ 主要看兩

深入理解 Java 反射：Class （反射的入口）

什麼是 Reflection 反射，為什麼要用它 Java 強型別語言，但是我們在執行時有了解、修改資訊的需求，包括類資訊、成員資訊以及陣列資訊。 Java 中 Reflection 和 Introspection 區別？ 說起反射，還有一個相似的概念 ‘Introspec

深入理解java反射機制

轉載自：https://blog.csdn.net/u012585964/article/details/52011138一，java的核心機制        java有兩種核心機制:java虛擬機器(JavaVirtual Machine)與垃圾收集機制(Garbage c

Java核心技術再理解——Java反射機制

在Java中反射是一種十分強大的機制，可以傳遞class，可以取得一個類的所有資訊，動態的生成一個類。甚至可以取得一個類的父類。同樣反射這一機制也是Java高階開發所必須掌握的。 能夠分析類能力的程式被稱為反射。本文將談到java.lang.Class，以及j

深入理解java反射機制中Method類中的invoke()方法

1.先說明Method類中的幾個重要的屬性 1）Method型別的root屬性： 可以理解為每一個 java方法都有唯一的一個Method物件，這個物件就是root，我們可以利用反射建立java方法的眾多的Method類的物件，這些物件指向root，可以理解為root的映象

深入理解 Java 反射和動態代理

深入理解Java：類加載機制及反射

指定 請求 image vm虛擬機 常量池 使用 元素 靜態 創建 一、Java類加載機制 1．概述 Class文件由類裝載器裝載後，在JVM中將形成一份描述Class結構的元信息對象，通過該元信息對象可以獲知Class的結構信息：如構造函數，屬性和方法等，J

理解Java的反射與內省及其區別

XML mat fun cal length [0 基礎 protocal 類名 java的內省機制和反射機制什麽區別 內省操作只針對JavaBean，只有符合JavaBean規則的類的成員才可以采用內省API進行操作。。。。而反射則不同，一個類的所有成員都可以進行反射操作

深入理解Java類型信息(Class對象)與反射機制

成員變量 字段 機制 () 程序 轉換 默認 數據 統一 　　深入理解Class對象　　　　RRTI的概念以及Class對象作用　　　　認識Class對象之前，先來了解一個概念，RTTI（Run-Time Type Identification）運行時類型識別，對於這個詞一

java反射與動態代理的理解

system 對象的訪問 讓我 integer 打破 類屬性 全部 列表 ces 一、什麽是反射機制？ 　　反射的官方定義是這樣的：在運行狀態中，對於任意的一個類，都能夠知道這個類的所有屬性和方法，對任意一個對象都能夠通過反射機制調用一個類的任意方法，這種動態獲取類信息及動

Java反射：如何正確理解，不如手寫一個(反射包分析、樓主親測)

Java反射機制、動態代理是基於什麼原理？ 這個問題可謂是老生常談的一個熱門問題了，如果沒有深入的思考還真的是很難回到上來。那麼今天我們一起來看看，如何正確清晰的認識這個熱門卻又說簡單又不簡單說複雜又比較複雜的問題。 一、什麼是反射 反射機制是Java語言提供的一種基礎功能

Java反射機制——動態代理的理解與程式碼體現！

package com.ITcore.cn; /** * @author 維宇——鮀城小帥 * 作於：2018-10-9 * 別代理物件 * */ public interface Father { //購買 public void buy(); }   packa

java反射機制一（反射的基本概念和理解）

反射就是對一個類進行解剖，把一個類中的各種成分對映成一個類 java程式執行位元組碼檔案的過程 1啟動jvm程序 2把所有相關的位元組碼加入記憶體（類載入器） 3.系統為每個位元組碼生成一個class物件 4初始化（靜態程式碼塊） 5靜態成員變數 得到一個類的C

(重要)Java反射機制(容易理解)

import java.lang.reflect.Method; class A {     private void cube (int n) {         System.out.println(n * n * n);     }     private void haha (int b

深入理解Java型別資訊(Class物件)與反射機制

關聯文章： 本篇主要是深入對Java中的Class物件進行分析，這對後續深入理解反射技術非常重要，主要內容如下： 深入理解Class物件 RRTI的概念以及Class物件作用 認識Class物件之前，先來了解一個概念，RTTI（Run-Time

深入理解java的反射機制（轉載）

今天將從以下4方面來系統的學習一下java的反射機制： java反射是什麼 java反射(Reflection)底層實現原理 java反射的簡單演示 java反射的應用場景 1，java反射是什麼 首先大家應該先了解兩個概念，編譯