2. 程式人生 > >Java經典反射例項

Java經典反射例項

阿新 • • 發佈：2018-12-23
Java提供了一套機制來動態執行方法和構造方法，以及陣列操作等，這套機制就叫——反射。反射機制是如今很多流行框架的實現基礎，其中包括Spring、Hibernate等。原理性的問題不是本文的重點，接下來讓我們在例項中學習這套精彩的機制。

1. 得到某個物件的屬性

Java程式碼 複製程式碼
  1. public Object getProperty(Object owner, String fieldName) throws Exception {         
  2.     Class ownerClass = owner.getClass();                                             
  3.     Field field = ownerClass.getField(fieldName);                                    
  4.     Object property = field.get(owner);                                              
  5.     return property;                                                                 
  6. }        
public Object getProperty(Object owner, String fieldName) throws Exception {       
    Class ownerClass = owner.getClass();                                           
                                                                                   
    Field field = ownerClass.getField(fieldName);                                  
                                                                                   
    Object property = field.get(owner);                                            
                                                                                   
    return property;                                                               
}

Class ownerClass = owner.getClass()：得到該物件的Class。

Field field = ownerClass.getField(fieldName)：通過Class得到類宣告的屬性。

Object property = field.get(owner)：通過物件得到該屬性的例項，如果這個屬性是非公有的，這裡會報IllegalAccessException。
2. 得到某個類的靜態屬性
Java程式碼 複製程式碼
  1. public Object getStaticProperty(String className, String fieldName)       
  2.             throws
     Exception {                                            
  3.     Class ownerClass = Class.forName(className);                          
  4.     Field field = ownerClass.getField(fieldName);                         
  5.     Object property = field.get(ownerClass);                              
  6.     return property;                                                      
  7. }      
public Object getStaticProperty(String className, String fieldName)     
            throws Exception {                                          
    Class ownerClass = Class.forName(className);                        
                                                                        
    Field field = ownerClass.getField(fieldName);                       
                                                                        
    Object property = field.get(ownerClass);                            
                                                                        
    return property;                                                    
}

Class ownerClass = Class.forName(className) ：首先得到這個類的Class。

Field field = ownerClass.getField(fieldName)：和上面一樣，通過Class得到類宣告的屬性。

Object property = field.get(ownerClass) ：這裡和上面有些不同，因為該屬性是靜態的，所以直接從類的Class裡取。


3. 執行某物件的方法
Java程式碼 複製程式碼
  1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {      
  2.     Class ownerClass = owner.getClass();      
  3.     Class[] argsClass = new Class[args.length];      
  4.     for (int i = 0, j = args.length; i < j; i++) {      
  5.         argsClass[i] = args[i].getClass();      
  6.     }       
  7.     Method method = ownerClass.getMethod(methodName, argsClass);         
  8.     return method.invoke(owner, args);       
  9. }     
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {    
    Class ownerClass = owner.getClass();    
    Class[] argsClass = new Class[args.length];    
    for (int i = 0, j = args.length; i < j; i++) {    
        argsClass[i] = args[i].getClass();    
    }     
    Method method = ownerClass.getMethod(methodName, argsClass);       
    return method.invoke(owner, args);     
}

Class owner_class = owner.getClass() ：首先還是必須得到這個物件的Class。

3～6行：配置引數的Class陣列，作為尋找Method的條件。

Method method = ownerClass.getMethod(methodName, argsClass)：通過Method名和引數的Class陣列得到要執行的Method。

method.invoke(owner, args)：執行該Method，invoke方法的引數是執行這個方法的物件，和引數陣列。返回值是Object，也既是該方法的返回值。


4. 執行某個類的靜態方法
Java程式碼 複製程式碼
  1. public Object invokeStaticMethod(String className, String methodName,               
  2.             Object[] args) throws Exception {                                       
  3.     Class ownerClass = Class.forName(className);                                    
  4.     Class[] argsClass = new Class[args.length];                                     
  5.     for (int i = 0, j = args.length; i < j; i++) {                                  
  6.         argsClass[i] = args[i].getClass();                                          
  7.     }                                                                               
  8.     Method method = ownerClass.getMethod(methodName, argsClass);                    
  9.     return method.invoke(null, args);                                               
  10. }                
public Object invokeStaticMethod(String className, String methodName,             
            Object[] args) throws Exception {                                     
    Class ownerClass = Class.forName(className);                                  
                                                                                  
    Class[] argsClass = new Class[args.length];                                   
                                                                                  
    for (int i = 0, j = args.length; i < j; i++) {                                
        argsClass[i] = args[i].getClass();                                        
    }                                                                             
                                                                                  
    Method method = ownerClass.getMethod(methodName, argsClass);                  
                                                                                  
    return method.invoke(null, args);                                             
}

基本的原理和例項3相同，不同點是最後一行，invoke的一個引數是null，因為這是靜態方法，不需要藉助例項執行。



5. 新建例項

Java程式碼 複製程式碼
  1. public Object newInstance(String className, Object[] args) throws Exception {       
  2.     Class newoneClass = Class.forName(className);                                   
  3.     Class[] argsClass = new Class[args.length];                                     
  4.     for (int i = 0, j = args.length; i < j; i++) {                                  
  5.         argsClass[i] = args[i].getClass();                                          
  6.     }                                                                               
  7.     Constructor cons = newoneClass.getConstructor(argsClass);                       
  8.     return cons.newInstance(args);                                                  
  9. }    
public Object newInstance(String className, Object[] args) throws Exception {     
    Class newoneClass = Class.forName(className);                                 
                                                                                  
    Class[] argsClass = new Class[args.length];                                   
                                                                                  
    for (int i = 0, j = args.length; i < j; i++) {                                
        argsClass[i] = args[i].getClass();                                        
    }                                                                             
                                                                                  
    Constructor cons = newoneClass.getConstructor(argsClass);                     
                                                                                  
    return cons.newInstance(args);                                                
                                                                                  
}

這裡說的方法是執行帶引數的建構函式來新建例項的方法。如果不需要引數，可以直接使用newoneClass.newInstance()來實現。

Class newoneClass = Class.forName(className)：第一步，得到要構造的例項的Class。

第6～第10行：得到引數的Class陣列。

Constructor cons = newoneClass.getConstructor(argsClass)：得到構造子。

cons.newInstance(args)：新建例項。


6. 判斷是否為某個類的例項

Java程式碼 複製程式碼
  1. publicboolean isInstance(Object obj, Class cls) {           
  2.     return cls.isInstance(obj);                              
  3. }      
public boolean isInstance(Object obj, Class cls) {         
    return cls.isInstance(obj);                            
}

7. 得到陣列中的某個元素
Java程式碼 複製程式碼
  1. public Object getByArray(Object array, int index) {          
  2.     return Array.get(array,index);                           
  3. }   
public Object getByArray(Object array, int index) {        
    return Array.get(array,index);                         
}

附完整原始碼：
Java程式碼 複製程式碼
  1. import java.lang.reflect.Array;      
  2. import java.lang.reflect.Constructor;      
  3. import java.lang.reflect.Field;      
  4. import java.lang.reflect.Method;      
  5. /**    
  6.  * Java Reflection Cookbook    
  7.  *    
  8.  * @author Michael Lee    
  9.  * @since 2006-8-23    
  10.  * @version 0.1a    
  11.  */
  12. publicclass Reflection {      
  13.     /**    
  14.      * 得到某個物件的公共屬性    
  15.      *    
  16.      * @param owner, fieldName    
  17.      * @return 該屬性物件    
  18.      * @throws Exception    
  19.      *    
  20.      */
  21.     public Object getProperty(Object owner, String fieldName) throws Exception {      
  22.         Class ownerClass = owner.getClass();      
  23.         Field field = ownerClass.getField(fieldName);      
  24.         Object property = field.get(owner);      
  25.         return property;      
  26.     }      
  27.     /**    
  28.      * 得到某類的靜態公共屬性    
  29.      *    
  30.      * @param className   類名    
  31.      * @param fieldName   屬性名    
  32.      * @return 該屬性物件    
  33.      * @throws Exception    
  34.      */
  35.     public Object getStaticProperty(String className, String fieldName)      
  36.             throws Exception {      
  37.         Class ownerClass = Class.forName(className);      
  38.         Field field = ownerClass.getField(fieldName);      
  39.         Object property = field.get(ownerClass);      
  40.         return property;      
  41.     }      
  42.     /**    
  43.      * 執行某物件方法    
  44.      *    
  45.      * @param owner    
  46.      *            物件    
  47.      * @param methodName    
  48.      *            方法名    
  49.      * @param args    
  50.      *            引數    
  51.      * @return 方法返回值    
  52.      * @throws Exception    
  53.      */
  54.     public Object invokeMethod(Object owner, String methodName, Object[] args)      
  55.             throws Exception {      
  56.         Class ownerClass = owner.getClass();      
  57.         Class[] argsClass = new Class[args.length];      
  58.         for (int i = 0, j = args.length; i < j; i++) {      
  59.             argsClass[i] = args[i].getClass();      
  60.         }      
  61.         Method method = ownerClass.getMethod(methodName, argsClass);      
  62.         return method.invoke(owner, args);      
  63.     }      
  64.       /**    
  65.      * 執行某類的靜態方法    
  66.      *    
  67.      * @param className    
  68.      *            類名    
  69.      * @param methodName    
  70.      *            方法名    
  71.      * @param args    
  72.      *            引數陣列    
  73.      * @return 執行方法返回的結果    
  74.      * @throws Exception    
  75.      */
  76.     public Object invokeStaticMethod(String className, String methodName,      
  77.             Object[] args) throws Exception {      
  78.         Class ownerClass = Class.forName(className);      
  79.         Class[] argsClass = new Class[args.length];      
  80.         for (int i = 0, j = args.length; i < j; i++) {      
  81.             argsClass[i] = args[i].getClass();      
  82.         }      
  83.         Method method = ownerClass.getMethod(methodName, argsClass);      
  84.         return method.invoke(null, args);      
  85.     }      
  86.     /**    
  87.      * 新建例項    
  88.      *    
  89.      * @param className    
  90.      *            類名    
  91.      * @param args    
  92.      *            建構函式的引數    
  93.      * @return 新建的例項    
  94.      * @throws Exception    
  95.      */
  96.     public Object newInstance(String className, Object[] args) throws Exception {      
  97.         Class newoneClass = Class.forName(className);      
  98.         Class[] argsClass = new Class[args.length];      
  99.         for (int i = 0, j = args.length; i < j; i++) {      
  100.             argsClass[i] = args[i].getClass();      
  101.         }      
  102.         Constructor cons = newoneClass.getConstructor(argsClass);      
  103.         return cons.newInstance(args);      
  104.     }      
  105.     /**    
  106.      * 是不是某個類的例項    
  107.      * @param obj 例項    
  108.      * @param cls 類    
  109.      * @return 如果 obj 是此類的例項，則返回 true    
  110.      */
  111.     publicboolean isInstance(Object obj, Class cls) {      
  112.         return cls.isInstance(obj);      
  113.     }      
  114.     /**    
  115.      * 得到陣列中的某個元素    
  116.      * @param array 陣列    
  117.      * @param index 索引    
  118.      * @return 返回指定陣列物件中索引元件的值    
  119.      */
  120.     public Object getByArray(Object array, int index) {      
  121.         return Array.get(array,index);      
  122.     }      
  123. }  

相關推薦

Java經典反射例項

Java提供了一套機制來動態執行方法和構造方法，以及陣列操作等，這套機制就叫——反射。反射機制是如今很多流行框架的實現基礎，其中包括Spring、Hibernate等。原理性的問題不是本文的重點，接下來讓我們在例項中學習這套精彩的機制。 1. 得到某個物件的屬性 Java程式

Java基礎-反射例項

反射最重要的用途就是開發各種通用框架，是框架設計的靈魂 很多框架（比如 Spring）都是配置化的（比如通過 XML檔案配置JavaBean，Action之類的），為了保證框架的通用性，他們可能根據配置檔案載入不同的物件或類，呼叫不同的方法，這個時候就必須用到反射——執行時

java 利用反射例項化類物件

package com.zhiru; /* * java 使用反射例項化一個類物件 * 第一種方式：建立類類物件，呼叫類類物件的newInatance方法獲取要例項化的類的物件，然後呼叫物件的s

Java基礎之反射例項（例項化Account與修改屬性）

要求：    設計Account類，並且新增屬性id、name、balance，新增get和set方法與存取錢的方法。    設計ReflectAccountTest類，例項化Account物件，存如100元，與取1000元的結果顯示。 &nb

Java中反射技術的例項

準備一個實體類： package test.reflect; /** * 反射使用的實體類 * * @author liulei on 2018/11/28 */ public class User { //欄位 private String username;

java利用反射獲取某個包下的所有獲取物件屬性、方法、並例項化

首先貼上用到的jar包，當然也可以通過遞迴file.list獲取類的路徑名稱。 maven匯入jar包： <dependency> <groupId>

JAVA反射例項詳解與介紹

我們都知道Java反射很重要，這次我來拋個磚頭！！！ 一：反射    反射是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性。   使用java的反射，一般有下面三步：     1：獲得你想操作類

Java反射例項（實戰方能理解jdk的各種方法）

什麼是反射？反射有什麼用處？ 1. 什麼是反射？ “反射（Reflection）能夠讓運行於JVM中的程式檢測和修改執行時的行為。”這個概念常常會和內省（Introspection）混淆，以下是這兩個術語在Wikipedia中的解釋： 內省用於在執行

java反射例項化物件

-Class類Java中手動建立的每一個類，在編譯後JVM都會為其建立一個Class類物件，在這個Class類物件中儲存了所建類的資訊。可通過Class類提供的方法為一個類例項化物件，區別與new關鍵字建立物件，前者是在類已經編譯好的情況下，通過指定類名來建立例項化物件，後者

java反射例項詳解

本文先講java反射的示例程式碼，希望看了程式碼以及分析對你有所幫助。  【案例1】通過一個物件獲得完整的包名和類名 package org.shen.own;  import java.util.Enumeration; 

Java使用new和反射例項化內部類物件

使用new和反射例項化內部類物件前兩天看到一道面試題，是關於內部類的知識，覺得很有意思，現對其詳細講解，絕對原創！~這道題是這樣的：根據註釋填寫(1)，(2)，(3)處的程式碼public class Test{public static void main(String[] args){// 初始化Be

Java經典設計模式之十一種行為型模式（附例項和詳解）

Java經典設計模式共有21中，分為三大類：建立型模式（5種）、結構型模式（7種）和行為型模式（11種）。 行為型模式細分為如下11種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯

Java經典例項：進階版堆疊實現，支援任何物件型別

支援任何物件型別，有更多的錯誤檢查。 package Stack; /** * Created by Frank */ public class MyStack<T> implements SimpleStack<T> { public stati

Java經典例項：紀元秒和本地日期時間互換

Java版本：1.8開始 import java.time.Instant; import java.time.ZoneId; import java.time.ZonedDateTime; /** * Created by Frank */ public class Curre

Java經典例項：把字串解析為日期時間

Java版本：1.8開始 import java.time.LocalDate; import java.time.LocalDateTime; /** * Created by Frank */ public class DateParse { public stati

Java經典例項：正則表示式，找到匹配的文字

import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Created by Frank */ public class REMatch { public static void main(

java構造方法、成員變數、方法所對應的反射例項

最原始的class類中包含著一些構造器，包，方法，屬性等等內容，我們可以通過位元組碼檔案得到對應的一個構造器 ，並指明是那種構造器通過引數進行設定，然後通過Constructior類進行例項物件 package test; import java.lang.reflec

Java反射02 : Class物件獲取的三種方式和通過反射例項化物件的兩種方式

1.Class物件獲取的三種方式 上一章節已經說過，一般情況下，Java反射操作都需要首先獲取Class物件。獲取Class物件的方式有三種。 公有屬性class 方法getClass()

Java讀取XML實現反射例項

* XML（Extensible Markup Language，可擴充套件標記語言）1、XML DOM解析：DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuil

Java中反射機制和Class.forName、例項物件.class(屬性)、例項物件getClass()的區別

二、Class.forName、例項物件.class(屬性)、例項物件getClass()的區別 1、相同點： 通過這幾種方式，得到的都是Java.lang.Class物件（這個是上面講到的 類在載入時獲得的最終產物） 例如： package demo;public class A{ public st