Java反射機制深入詳解
- 巴扎黑原創
- 2017-06-23 16:38:481287瀏覽
一.概念
反射就是把Java的各種成分映射成對應的Java類別。
Class類別的建構方法是private，由JVM建立。
反射是java語言的一個特性，它允程式在執行時（注意不是編譯的時候）來進行自我檢查並且對內部的成員進行操作。例如它允許一個java的類別取得他所有的成員變數和方法並且顯示出來。 Java 的這項能力在實際應用上也許用得不是很多，但是在其它的程式設計語言中根本就不存在這一特性。例如，Pascal、C 或 C++ 中就沒有辦法在程式中取得函數定義相關的資訊。 （取自Sun）
JavaBean 是 reflection 的實際應用之一，它能讓一些工具視覺化的操作軟體元件。這些工具透過 reflection 動態的載入並取得 Java 元件(類別) 的屬性。
反射是從1.2就有的，後面的三大框架都會用到反射機制,涉及到類別"Class",無法直接new CLass()，其物件是記憶體裡的一份字節碼.
Class 類別的實例表示正在執行的Java 應用程式中的類別和介面。枚舉是一種類，註解是一種介面。每個數組屬於被映射為 Class 物件的一個類，所有具有相同元素類型和維數的數組都共用該 Class 物件。基本的 Java型別（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示為 Class 物件。 Class 沒有公共構造方法。 Class 物件是在載入類別時由 Java 虛擬機器以及透過呼叫類別載入器中的 defineClass 方法自動建構的。
1 Person p1 = new Person();
2 //下面的这三种方式都可以得到字节码
3 CLass c1 = Date.class();
4 p1.getClass();
5 //若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来
6 Class.forName("java.lang.String");CLass.forName()字節碼已經載入到java虛擬機器中，去得到字節碼；java虛擬機中還沒有產生字節碼用類別載入器進行加載，加載的字節碼緩衝到虛擬機器中。
考慮下面這個簡單的例子，讓我們看看 reflection 是如何運作的。
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName("java.util.Stack");
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);
}
}
}
1 public synchronized java.lang.Object java.util.Stack.pop() 2 public java.lang.Object java.util.Stack.push(java.lang.Object) 3 public boolean java.util.Stack.empty() 4 public synchronized java.lang.Object java.util.Stack.peek() 5 public synchronized int java.util.Stack.search(java.lang.Object)
#
這樣就列出了java.util.Stack 類別的各方法名稱以及它們的限制符和返回類型。這個程式使用 Class.forName 載入指定的類，然後呼叫 getDeclaredMethods 來取得這個類別中定義了的方法清單。 java.lang.reflect.Methods 是用來描述某個類別中單一方法的類別。
以下範例使用Class 物件來顯示物件的類別名稱：
1 void printClassName(Object obj) {
2 System.out.println("The class of " + obj +
3 " is " + obj.getClass().getName());
4 }也可以使用一個類別字面值（JLS Section 15.8.2）來取得指定類型（或void）的Class 物件。例如：
1 System.out.println("The name of class Foo is: "+Foo.class.getName());在沒有物件實例的時候，主要有兩種方法。
//获得类类型的两种方式
Class cls1 = Role.class;
Class cls2 = Class.forName("yui.Role");注意第二種方式中，forName中的參數一定是完整的類別名稱（包名+類別名稱），而這個方法需要擷取例外。現在得到cls1就可以建立一個Role類別的實例了，利用Class的newInstance方法相當於呼叫類別的預設的建構器。
1 Object o = cls1.newInstance(); 2 //创建一个实例 3 //Object o1 = new Role(); //与上面的方法等价
二.常用方法
1.isPrimitive(判斷是否為基本型別的字節碼)
public class TestReflect {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = "abc";
Class cls1 = str.getClass();
Class cls2 = String.class;
Class cls3 = null;//必须要加上null
try {
cls3 = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);
System.out.println(cls1.isPrimitive());
System.out.println(int.class.isPrimitive());//判定指定的 Class 对象是否表示一个基本类型。
System.out.println(int.class == Integer.class);
System.out.println(int.class == Integer.TYPE);
System.out.println(int[].class.isPrimitive());
System.out.println(int[].class.isArray());
}
}
/*
* true
true
false
true
false
true
false
true
*/
*/ 2.getConstructor和getConstructors()
java中建構方法沒有先後順序，透過型別和參數個數來區分。
1 public class TestReflect {
2 public static void main(String[] args) throws SecurityException, NoSuchMethodException {
3 // TODO Auto-generated method stub
4 String str = "abc";
5
6 System.out.println(String.class.getConstructor(StringBuffer.class));
7 }
8 }3.Filed類別代表某一類別中的一個成員變數。
1 import java.lang.reflect.Field;
2 public class TestReflect {
3 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
4 ReflectPointer rp1 = new ReflectPointer(3,4);
5 Field fieldx = rp1.getClass().getField("x");//必须是x或者y
6 System.out.println(fieldx.get(rp1));
7
8 /*
9 * private的成员变量必须使用getDeclaredField，并setAccessible(true),否则看得到拿不到
10 */
11 Field fieldy = rp1.getClass().getDeclaredField("y");
12 fieldy.setAccessible(true);//暴力反射
13 System.out.println(fieldy.get(rp1));
14
15 }
16 }
17
18 class ReflectPointer {
19
20 public int x = 0;
21 private int y = 0;
22
23 public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source
24 super();
25 // TODO Auto-generated constructor stub
26 this.x = x;
27 this.y = y;
28 }
29 }4.
三.典型範例
1.將所有String類型的成員變數裡的b改成a。
1 import java.lang.reflect.Field;
2 public class TestReflect {
3 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
4 ReflectPointer rp1 = new ReflectPointer(3,4);
5 changeBtoA(rp1);
6 System.out.println(rp1);
7
8 }
9
10 private static void changeBtoA(Object obj) throws RuntimeException, Exception {
11 Field[] fields = obj.getClass().getFields();
12
13 for(Field field : fields) {
14 //if(field.getType().equals(String.class))
15 //由于字节码只有一份,用equals语义不准确
16 if(field.getType()==String.class) {
17 String oldValue = (String)field.get(obj);
18 String newValue = oldValue.replace('b', 'a');
19 field.set(obj,newValue);
20 }
21 }
22 }
23 }
24
25 class ReflectPointer {
26
27 private int x = 0;
28 public int y = 0;
29 public String str1 = "ball";
30 public String str2 = "basketball";
31 public String str3 = "itcat";
32
33 public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source
34 super();
35 // TODO Auto-generated constructor stub
36 this.x = x;
37 this.y = y;
38 }
39
40 @Override
41 public String toString() {
42 return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="
43 + str3 + "]";
44 }
45 }2.寫一個程式根據使用者提供的類別名，呼叫該類別的里的main方法。
為什麼要用反射的方式呢？
1 import java.lang.reflect.Field;
2 import java.lang.reflect.Method;
3
4 public class TestReflect {
5 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
6 String str = args[0];
7 /*
8 * 这样会数组角标越界，因为压根没有这个字符数组
9 * 需要右键在run as-configurations-arguments里输入b.Inter（完整类名）
10 *
11 */
12 Method m = Class.forName(str).getMethod("main",String[].class);
13 //下面这两种方式都可以,main方法需要一个参数
14
15 m.invoke(null, new Object[]{new String[]{"111","222","333"}});
16 m.invoke(null, (Object)new String[]{"111","222","333"});//这个可以说明，数组也是Object
17 /*
18 * m.invoke(null, new String[]{"111","222","333"})
19 * 上面的不可以,因为java会自动拆包
20 */
21 }
22 }
23
24 class Inter {
25 public static void main(String[] args) {
26 for(Object obj : args) {
27 System.out.println(obj);
28 }
29 }
30 }3.模擬instanceof 運算子
class S {
}
public class IsInstance {
public static void main(String args[]) {
try {
Class cls = Class.forName("S");
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new S());
System.out.println(b2);
}
catch (Throwable e) {
System.err.println(e);
}
}
}
在這個範例中建立了一個S 類別的Class 物件，然後檢查一些物件是否是S的實例。 Integer(37) 不是，但 new S()是。
四.Method類別
代表類別（不是物件）中的某一方法。
1 import java.lang.reflect.Field;
2 import java.lang.reflect.Method;
3 /*
4 * 人在黑板上画圆，涉及三个对象,画圆需要圆心和半径，但是是私有的，画圆的方法
5 * 分配给人不合适。
6 *
7 * 司机踩刹车，司机只是给列车发出指令，刹车的动作还需要列车去完成。
8 *
9 * 面试经常考面向对象的设计，比如人关门，人只是去推门。
10 *
11 * 这就是专家模式：谁拥有数据，谁就是专家,方法就分配给谁
12 */
13 public class TestReflect {
14 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
15 String str = "shfsfs";
16 //包开头是com表示是sun内部用的，java打头的才是用户的
17 Method mtCharAt = String.class.getMethod("charAt", int.class);
18 Object ch = mtCharAt.invoke(str,1);//若第一个参数是null，则肯定是静态方法
19 System.out.println(ch);
20
21 System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4语法
22
23 }
24
25 }
#五.陣列的反射
Array工具類別用於完成陣列的反射運算。
同類型同緯度有相同的字節碼。
int.class和Integer.class不是同一份字節碼，Integer.TYPE，TYPE代表包裝類別對應的基本類別的字節碼 int.class==Integer.TYPE
1 import java.util.Arrays;
2
3 /*
4 * 从这个例子看出即便字节码相同但是对象也不一定相同,根本不是一回事
5 *
6 */
7 public class TestReflect {
8 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
9 int[] a = new int[3];
10 int[] b = new int[]{4,5,5};//直接赋值后不可以指定长度，否则ＣＥ
11 int[][] c = new int[3][2];
12 String[] d = new String[]{"jjj","kkkk"};
13 System.out.println(a==b);//false
14 System.out.println(a.getClass()==b.getClass());//true
15 //System.out.println(a.getClass()==d.getClass()); //比较字节码a和cd也没法比
16 System.out.println(a.getClass());//输出class [I
17 System.out.println(a.getClass().getName());//输出[I,中括号表示数组，I表示整数
18
19 System.out.println(a.getClass().getSuperclass());//输出class java.lang.Object
20 System.out.println(d.getClass().getSuperclass());//输出class java.lang.Object
21
22 //由于父类都是Object,下面都是可以的
23 Object obj1 = a;//不可是Object[]
24 Object obj2 = b;
25 Object[] obj3 = c;//基本类型的一位数组只可以当做Object，非得还可以当做Object[]
26 Object obj4 = d;
27
28 //注意asList处理int[]和String[]的区别
29 System.out.println(Arrays.asList(b));//1.4没有可变参数，使用的是数组,[[I@1bc4459]
30 System.out.println(Arrays.asList(d));//[jjj, kkkk]
31
32 }
33 }
六.結束語
以上就是反射機制的簡單的使用，顯然學過spring的朋友一定明白了，為什麼可以通過配置文件就可以讓我們獲得指定的方法和變量，在我們創建對象的時候都是透過傳進string實現的，就好像你需要什麼，我們去為你生產，還有我們一直在用Object,這就說明java語言的動態特性，依賴性大大的降低了。
#學習Java的同學注意了！ ！ ！
學習過程中遇到什麼問題或想取得學習資源的話，歡迎加入Java學習交流群：159610322 我們一起學習Java！
以上是Java反射機制深入詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！