作者：火星十一郎
https://www.cnblogs.com/hxsyl
一.概念
反射就是把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 方法自動構造的，
Person p1 = new Person();
//下面的這三種方式都可以得到位元組碼
CLass c1 = Date.class();
p1.getClass();
//若存在則加載，否則新建,往往使用第三種,類的名字在寫源程式時不需要知道，到運行時再傳遞過來
Class.forName("java.lang.String");
Class.forName()位元組碼已經加載到java虛擬機中，去得到位元組碼；java虛擬機中還沒有生成位元組碼 用類加載器進行加載，加載的位元組碼緩沖到虛擬機中，
另外，大家可以關注微信公眾號Java技術堆疊回復：JVM，獲取我整理的系列JVM教程，都是干貨，
考慮下面這個簡單的例子，讓我們看看 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);
}
}
}
public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)
這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和回傳型別，這個程式使用 Class.forName 載入指定的類，然后呼叫 getDeclaredMethods 來獲取這個類中定義了的方法串列，java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類，
以下示例使用 Class 物件來顯示物件的類名：
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
還可以使用一個類字面值（JLS Section 15.8.2）來獲取指定型別（或 void）的 Class 物件，例如：
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方法相當于呼叫類的默認的構造器，
Object o = cls1.newInstance();
//創建一個實體
//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中構造方法沒有先后順序，通過型別和引數個數區分，
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException {
// TODO Auto-generated method stub
String str = "abc";
System.out.println(String.class.getConstructor(StringBuffer.class));
}
}
3.Filed類代表某一類中的一個成員變數，
import java.lang.reflect.Field;
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
ReflectPointer rp1 = new ReflectPointer(3,4);
Field fieldx = rp1.getClass().getField("x");//必須是x或者y
System.out.println(fieldx.get(rp1));
/*
* private的成員變數必須使用getDeclaredField，并setAccessible(true),否則看得到拿不到
*/
Field fieldy = rp1.getClass().getDeclaredField("y");
fieldy.setAccessible(true);//暴力反射
System.out.println(fieldy.get(rp1));
}
}
class ReflectPointer {
public int x = 0;
private int y = 0;
public ReflectPointer(int x,int y) {//alt + shift +s相當于右鍵source
super();
// TODO Auto-generated constructor stub
this.x = x;
this.y = y;
}
}
三.典型例題
1.將所有String型別的成員變數里的b改成a，
import java.lang.reflect.Field;
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
ReflectPointer rp1 = new ReflectPointer(3,4);
changeBtoA(rp1);
System.out.println(rp1);
}
private static void changeBtoA(Object obj) throws RuntimeException, Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields) {
//if(field.getType().equals(String.class))
//由于位元組碼只有一份,用equals語意不準確
if(field.getType()==String.class) {
String oldValue = https://www.cnblogs.com/javastack/p/(String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj,newValue);
}
}
}
}
class ReflectPointer {
private int x = 0;
public int y = 0;
public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "itcat";
public ReflectPointer(int x,int y) {//alt + shift +s相當于右鍵source
super();
// TODO Auto-generated constructor stub
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="
+ str3 + "]";
}
}
2.寫一個程式根據用戶提供的類名，呼叫該類的里的main方法，
為什么要用反射的方式呢？
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
String str = args[0];
/*
* 這樣會陣列角標越界，因為壓根沒有這個字符陣列
* 需要右鍵在run as-configurations-arguments里輸入b.Inter（完整類名）
*
*/
Method m = Class.forName(str).getMethod("main",String[].class);
//下面這兩種方式都可以,main方法需要一個引數
m.invoke(null, new Object[]{new String[]{"111","222","333"}});
m.invoke(null, (Object)new String[]{"111","222","333"});//這個可以說明，陣列也是Object
/*
* m.invoke(null, new String[]{"111","222","333"})
* 上面的不可以,因為java會自動拆包
*/
}
}
class Inter {
public static void main(String[] args) {
for(Object obj : args) {
System.out.println(obj);
}
}
}
**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()是，
推薦閱讀：instanceof、isInstance、isAssignableFrom
四.Method類
代表類（不是物件）中的某一方法，
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
* 人在黑板上畫圓，涉及三個物件,畫圓需要圓心和半徑，但是是私有的，畫圓的方法
* 分配給人不合適，
*
* 司機踩剎車，司機只是給列車發出指令，剎車的動作還需要列車去完成，
*
* 面試經常考面向物件的設計，比如人關門，人只是去推門，
*
* 這就是專家模式：誰擁有資料，誰就是專家,方法就分配給誰
*/
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
String str = "shfsfs";
//包開頭是com表示是sun內部用的，java打頭的才是用戶的
Method mtCharAt = String.class.getMethod("charAt", int.class);
Object ch = mtCharAt.invoke(str,1);//若第一個引數是null，則肯定是靜態方法
System.out.println(ch);
System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4語法
}
}
五.陣列的反射
Array工具類用于完成陣列的反射操作，
同型別同緯度有相同的位元組碼，
int.class和Integer.class不是同一份位元組碼，Integer.TYPE，TYPE代表包裝類對應的基本類的位元組碼 int.class==Integer.TYPE，
import java.util.Arrays;
/*
* 從這個例子看出即便位元組碼相同但是物件也不一定相同,根本不是一回事
*
*/
public class TestReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
int[] a = new int[3];
int[] b = new int[]{4,5,5};//直接賦值后不可以指定長度，否則ＣＥ
int[][] c = new int[3][2];
String[] d = new String[]{"jjj","kkkk"};
System.out.println(a==b);//false
System.out.println(a.getClass()==b.getClass());//true
//System.out.println(a.getClass()==d.getClass()); //比較位元組碼a和cd也沒法比
System.out.println(a.getClass());//輸出class [I
System.out.println(a.getClass().getName());//輸出[I,中括號表示陣列，I表示整數
System.out.println(a.getClass().getSuperclass());//輸出class java.lang.Object
System.out.println(d.getClass().getSuperclass());//輸出class java.lang.Object
//由于父類都是Object,下面都是可以的
Object obj1 = a;//不可是Object[]
Object obj2 = b;
Object[] obj3 = c;//基本型別的一位陣列只可以當做Object，非得還可以當做Object[]
Object obj4 = d;
//注意asList處理int[]和String[]的區別
System.out.println(Arrays.asList(b));//1.4沒有可變引數，使用的是陣列,[[I@1bc4459]
System.out.println(Arrays.asList(d));//[jjj, kkkk]
}
}
六.結束語
以上就是反射機制的簡單的使用，顯然學過spring的朋友一定明白了，為什么可以通過組態檔就可以讓我們獲得指定的方法和變數，在我們創建物件的時候都是通過傳進string實作的，就好像你需要什么，我們去為你生產，還有我們一直在用Object,這就說明java語言的動態特性，依賴性大大的降低了，
本文著作權歸作者火星十一郎所有，歡迎轉載和商用，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利.
關注公眾號Java技術堆疊回復"面試"獲取我整理的2020最全面試題及答案，
推薦去我的博客閱讀更多：
1.Java JVM、集合、多執行緒、新特性系列教程
2.Spring MVC、Spring Boot、Spring Cloud 系列教程
3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程
4.Java、后端、架構、阿里巴巴等大廠最新面試題
覺得不錯，別忘了點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/149773.html
標籤：Java