Java中反射的學習筆記分享
簡介
反射是Java編程語言中的一個特性。它允許執行的Java程序檢查或 操作 自身，並操作程序的內部屬性。例如，Java類可以獲取其所有成員的名稱並顯示它們。
從程序內部檢查和操作Java類的能力聽起來可能不太顯示，但是在其他編程語言中，這個特性根本不存在。例如，在C或C ++ 程序中無法獲取有關該程序中定義的函數的信息。
反射的一個具體用途是在JavaBeans中，軟件組件可以通過一個構建工具進行可視化操作。該工具使用反射來獲取Java組件 (類) 動態加載時的屬性。
一個簡單的例子
要瞭解反射是如何工作的，請考慮以下簡單示例:
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());
在下面的示例中，將三個步驟結合在一起，以呈現如何使用反射處理特定應用的獨立插圖。
模擬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被創建，然後我們檢查類實例對象，以查看它們是否是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方法，但直到執行時才知道。也就是說，在執行期間指定方法的名稱 (例如，這可以由JavaBeans開發環境完成)。上面的程序展示瞭一種方法。
getMethod用於在類中查找具有兩個integer參數類型並具有適當名稱的方法。一旦找到此方法並將其捕獲到Method 對象，它是在適當類型的對象實例上調用的。要調用方法，必須構造一個參數列表，基本整數值為37和47Integer 對象。返回值 (84) 也被包含在Integer 對象。
創建新對象
構造函數不等同於方法調用，因為調用構造函數等同於創建新對象 (最準確地說，創建新對象涉及內存分配和對象構造)。所以最接近前面例子的是:
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);
}
}
}
它查找處理指定參數類型並調用它的構造函數，以創建對象的新實例。這種方法的價值在於它純粹是動態的，在執行時而不是在編譯時使用構造函數查找和調用。
更改字段的值
反射的另一個用途是改變對象中數據字段的值。它的值再次從反射的動態性質中導出，其中可以在執行程序中按名稱查找字段，然後更改其值。以下示例說明瞭這一點:
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。
使用數組
反射的一個用途是創建和操作數組。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);
}
}
}
此示例創建一個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]);
}
}
此示例創建一個5x10x15的int數組，然後繼續將數組中的位置 [3][5][10] 設置為值37。請註意，多維數組實際上是數組數組，因此，例如，在第一個array.get之後，arrobj中的結果是10×15數組。再次將其剝離以獲得15長的數組，並使用Array.setInt。
請註意，創建的數組類型是動態的，不必在編譯時知道。
總結
Java反射非常有用，因為它支持按名稱動態檢索有關類和數據結構的信息，並允許在執行的Java程序中進行操作。此功能非常強大，但是也要謹慎使用
以上就是Java中反射的學習筆記分享的詳細內容，更多關於Java反射的資料請關註WalkonNet其它相關文章！