Java中反射的學習筆記分享
簡介
反射是Java編程語言中的一個特性。它允許執(zhí)行的Java程序檢查或 操作 自身,并操作程序的內部屬性。例如,Java類可以獲取其所有成員的名稱并顯示它們。
從程序內部檢查和操作Java類的能力聽起來可能不太顯示,但是在其他編程語言中,這個特性根本不存在。例如,在C或C ++ 程序中無法獲取有關該程序中定義的函數的信息。
反射的一個具體用途是在JavaBeans中,軟件組件可以通過一個構建工具進行可視化操作。該工具使用反射來獲取Java組件 (類) 動態(tài)加載時的屬性。
一個簡單的例子
要了解反射是如何工作的,請考慮以下簡單示例:
import java.lang.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); } catch (Throwable e) { System.err.println(e); } } }
對于以下項的調用:
java DumpMethods java.util.Stack
輸出為:
public java.lang.Object java.util.Stack.push( java.lang.Object) public synchronized java.lang.Object java.util.Stack.pop() public synchronized java.lang.Object java.util.Stack.peek() public boolean java.util.Stack.empty() public synchronized int java.util.Stack.search(java.lang.Object)
也就是說,類的方法名稱java.util.Stack
列出了它們及其完全限定的參數和返回類型。
此程序使用加載指定的類 class.forName
, 然后調用 getDeclaredMethods
方法檢索類中定義的方法列表. java.lang.reflect.Method
是表示單個類方法的類。
設置使用反射
反射類,例如Method
,在java.lang.反射中找到。使用這些類必須遵循三個步驟。第一步是獲得一個java.lang.Class
要操作的類的對象。java.lang.Class
用于表示正在運行的Java程序中的類和接口。
獲取類對象的一種方法是:
Class c = Class.forName("java.lang.String");
上述代碼獲取的類對象 String
.
另一種方法是使用:
Class c = int.class;
或者
Class c = Integer.TYPE;
獲取基本類型的類信息。后一種方法訪問預定義TYPE
包裝類型 (例如Integer
) 為基本類型。
第二步是調用方法,例如getDeclaredMethods
,以獲取該類聲明的所有方法的列表。
一旦掌握了這些信息,那么第三步就是使用反射API來操作這些信息。例如:
Class c = Class.forName("java.lang.String"); Method m[] = c.getDeclaredMethods(); System.out.println(m[0].toString());
在下面的示例中,將三個步驟結合在一起,以呈現(xiàn)如何使用反射處理特定應用的獨立插圖。
模擬instanceof運算
一旦掌握了類信息,下一步通常是詢問有關類對象的基本問題。
例如,Class.isInstance
方法可以用來模擬instanceof
運算:
class A {} public class instance1 { public static void main(String args[]) { try { Class cls = Class.forName("A"); boolean b1 = cls.isInstance(new Integer(37)); System.out.println(b1); boolean b2 = cls.isInstance(new A()); System.out.println(b2); } catch (Throwable e) { System.err.println(e); } } }
在此示例中,類對象A
被創(chuàng)建,然后我們檢查類實例對象,以查看它們是否是A
。Integer(37)
不是,但是new A()
是。
了解類的方法
反射最有價值和最基本的用途之一是找出類中定義了哪些方法。為此,可以使用以下代碼:
import java.lang.reflect.*; public class method1 { private int f1( Object p, int x) throws NullPointerException { if (p == null) throw new NullPointerException(); return x; } public static void main(String args[]) { try { Class cls = Class.forName("method1"); Method methlist[] = cls.getDeclaredMethods(); for (int i = 0; i < methlist.length; i++) { Method m = methlist[i]; System.out.println("name = " + m.getName()); System.out.println("decl class = " + m.getDeclaringClass()); Class pvec[] = m.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println(" param #" + j + " " + pvec[j]); Class evec[] = m.getExceptionTypes(); for (int j = 0; j < evec.length; j++) System.out.println("exc #" + j + " " + evec[j]); System.out.println("return type = " + m.getReturnType()); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }
程序首先獲取method1的類描述,然后調用getDeclaredMethods
(一個用于獲取類中定義的每個方法的函數)檢索Method
對象列表。這些方法包括public、protect、package和priva。如果你在程序中使用getMethods
而不是getDeclaredMethods
,還可以獲取繼承方法的信息。
程序的輸出為:
name = f1 decl class = class method1 param #0 class java.lang.Object param #1 int exc #0 class java.lang.NullPointerException return type = int ----- name = main decl class = class method1 param #0 class [Ljava.lang.String; return type = void -----
獲取有關構造函數的信息
使用類似的方法來找出類的構造函數。例如:
import java.lang.reflect.*; public class constructor1 { public constructor1() { } protected constructor1(int i, double d) { } public static void main(String args[]) { try { Class cls = Class.forName("constructor1"); Constructor ctorlist[] = cls.getDeclaredConstructors(); for (int i = 0; i < ctorlist.length; i++) { Constructor ct = ctorlist[i]; System.out.println("name = " + ct.getName()); System.out.println("decl class = " + ct.getDeclaringClass()); Class pvec[] = ct.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println("param #" + j + " " + pvec[j]); Class evec[] = ct.getExceptionTypes(); for (int j = 0; j < evec.length; j++) System.out.println( "exc #" + j + " " + evec[j]); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }
在此示例中沒有檢索到返回類型信息,因為構造函數實際上沒有真正的返回類型。
運行此程序時,輸出為:
name = constructor1 decl class = class constructor1 ----- name = constructor1 decl class = class constructor1 param #0 int param #1 double -----
查找類字段
還可以找出類中定義了哪些數據字段。為此,可以使用以下代碼:
import java.lang.reflect.*; public class field1 { private double d; public static final int i = 37; String s = "testing"; public static void main(String args[]) { try { Class cls = Class.forName("field1"); Field fieldlist[] = cls.getDeclaredFields(); for (int i = 0; i < fieldlist.length; i++) { Field fld = fieldlist[i]; System.out.println("name = " + fld.getName()); System.out.println("decl class = " + fld.getDeclaringClass()); System.out.println("type = " + fld.getType()); int mod = fld.getModifiers(); System.out.println("modifiers = " + Modifier.toString(mod)); System.out.println("-----"); } } catch (Throwable e) { System.err.println(e); } } }
此示例與前面的示例相似。一個新功能是使用Modifier
。這是一個反射類,表示在字段成員上找到的修飾符,例如private int
。修飾符本身由整數表示,并且Modifier.toString
用于返回默認聲明順序中的字符串表示形式 (例如final
之前的static
)。程序的輸出為:
name = d decl class = class field1 type = double modifiers = private ----- name = i decl class = class field1 type = int modifiers = public static final ----- name = s decl class = class field1 type = class java.lang.String modifiers = -----
與方法一樣,可以僅獲取有關類中聲明的字段的信息 (getDeclaredFields
),或獲取有關超類中定義的字段的信息 (getFields
)。
按名稱調用方法
到目前為止,已經提出的例子都與獲取class有關。但是也可以以其他方式使用反射,例如調用指定名稱的方法。
要了解其工作原理,請考慮以下示例:
import java.lang.reflect.*; public class method2 { public int add(int a, int b) { return a + b; } public static void main(String args[]) { try { Class cls = Class.forName("method2"); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; Method meth = cls.getMethod( "add", partypes); method2 methobj = new method2(); Object arglist[] = new Object[2]; arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = meth.invoke(methobj, arglist); Integer retval = (Integer)retobj; System.out.println(retval.intValue()); } catch (Throwable e) { System.err.println(e); } } }
假設一個程序想要調用add
方法,但直到執(zhí)行時才知道。也就是說,在執(zhí)行期間指定方法的名稱 (例如,這可以由JavaBeans開發(fā)環(huán)境完成)。上面的程序展示了一種方法。
getMethod
用于在類中查找具有兩個integer參數類型并具有適當名稱的方法。一旦找到此方法并將其捕獲到Method
對象,它是在適當類型的對象實例上調用的。要調用方法,必須構造一個參數列表,基本整數值為37和47Integer
對象。返回值 (84) 也被包含在Integer
對象。
創(chuàng)建新對象
構造函數不等同于方法調用,因為調用構造函數等同于創(chuàng)建新對象 (最準確地說,創(chuàng)建新對象涉及內存分配和對象構造)。所以最接近前面例子的是:
import java.lang.reflect.*; public class constructor2 { public constructor2() { } public constructor2(int a, int b) { System.out.println( "a = " + a + " b = " + b); } public static void main(String args[]) { try { Class cls = Class.forName("constructor2"); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; Constructor ct = cls.getConstructor(partypes); Object arglist[] = new Object[2]; arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = ct.newInstance(arglist); } catch (Throwable e) { System.err.println(e); } } }
它查找處理指定參數類型并調用它的構造函數,以創(chuàng)建對象的新實例。這種方法的價值在于它純粹是動態(tài)的,在執(zhí)行時而不是在編譯時使用構造函數查找和調用。
更改字段的值
反射的另一個用途是改變對象中數據字段的值。它的值再次從反射的動態(tài)性質中導出,其中可以在執(zhí)行程序中按名稱查找字段,然后更改其值。以下示例說明了這一點:
import java.lang.reflect.*; public class field2 { public double d; public static void main(String args[]) { try { Class cls = Class.forName("field2"); Field fld = cls.getField("d"); field2 f2obj = new field2(); System.out.println("d = " + f2obj.d); fld.setDouble(f2obj, 12.34); System.out.println("d = " + f2obj.d); } catch (Throwable e) { System.err.println(e); } } }
在此示例中,d字段的值設置為12.34。
使用數組
反射的一個用途是創(chuàng)建和操作數組。Java語言中的數組是類的一種特殊類型,并且可以將數組引用分配給Object
。
要查看數組的工作方式,請考慮以下示例:
import java.lang.reflect.*; public class array1 { public static void main(String args[]) { try { Class cls = Class.forName( "java.lang.String"); Object arr = Array.newInstance(cls, 10); Array.set(arr, 5, "this is a test"); String s = (String)Array.get(arr, 5); System.out.println(s); } catch (Throwable e) { System.err.println(e); } } }
此示例創(chuàng)建一個10長的字符串數組,然后將數組中的位置5設置為字符串值。將檢索并顯示該值。
以下代碼說明了對數組的更復雜的操作:
import java.lang.reflect.*; public class array2 { public static void main(String args[]) { int dims[] = new int[]{5, 10, 15}; Object arr = Array.newInstance(Integer.TYPE, dims); Object arrobj = Array.get(arr, 3); Class cls = arrobj.getClass().getComponentType(); System.out.println(cls); arrobj = Array.get(arrobj, 5); Array.setInt(arrobj, 10, 37); int arrcast[][][] = (int[][][])arr; System.out.println(arrcast[3][5][10]); } }
此示例創(chuàng)建一個5x10x15的int數組,然后繼續(xù)將數組中的位置 [3][5][10] 設置為值37。請注意,多維數組實際上是數組數組,因此,例如,在第一個array.get之后,arrobj中的結果是10x15數組。再次將其剝離以獲得15長的數組,并使用Array.setInt
。
請注意,創(chuàng)建的數組類型是動態(tài)的,不必在編譯時知道。
總結
Java反射非常有用,因為它支持按名稱動態(tài)檢索有關類和數據結構的信息,并允許在執(zhí)行的Java程序中進行操作。此功能非常強大,但是也要謹慎使用
以上就是Java中反射的學習筆記分享的詳細內容,更多關于Java反射的資料請關注腳本之家其它相關文章!
相關文章
java多線程處理執(zhí)行solr創(chuàng)建索引示例
這篇文章主要介紹了java多線程處理執(zhí)行solr創(chuàng)建索引示例,需要的朋友可以參考下2014-02-02Java中的CopyOnWriteArrayList你了解嗎
CopyOnWriteArrayList是Java集合框架中的一種線程安全的List實現(xiàn),這篇文章主要來和大家聊聊CopyOnWriteArrayList的簡單使用,需要的可以參考一下2023-06-06Java中l(wèi)ombok的@Builder注解的解析與簡單使用詳解
這篇文章主要介紹了Java中l(wèi)ombok的@Builder注解的解析與簡單使用,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2021-01-01springcloud 熔斷監(jiān)控Hystrix Dashboard和Turbine
這篇文章主要介紹了springcloud 熔斷監(jiān)控Hystrix Dashboard和Turbine,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2019-08-08SpringBoot+Vue+Flowable模擬實現(xiàn)請假審批流程
這篇文章主要為大家詳細介紹了如何利用SpringBoot+Vue+Flowable模擬實現(xiàn)一個請假審批流程,文中的示例代碼講解詳細,需要的可以參考一下2022-08-08