㈠ 一文讀懂java中的反射，邊學邊實戰！
Java中的反射機制在運行時為我們提供了動態獲取類信息和對象方法的能力，是框架設計的核心要素。雖然在日常項目開發中用得不多，但它在模塊化開發、動態代理設計模式、Spring和Hibernate等框架中扮演著關鍵角色。
Class類是Java中描述數據類型（包括基本類型和引用類型）的關鍵。每個class在運行時對應一個JVM內部的Class實例，它包含了類的全名、包名、父類、介面、方法和欄位等詳細信息。獲取Class實例有四種常見方式：通過類的靜態變數、使用Class.forName()、實例的getClass()或通過ClassLoader.loadClass()。
反射的核心是通過Class實例獲取類的信息，如欄位和方法。例如，我們可以獲取到一個對象的欄位類型和值，甚至修改這些值，盡管這可能破壞封裝性。對於非public欄位和方法，通常需要先調用setAccessible(true)來解除訪問限制，但此操作可能因為安全策略而受限。
通過Method對象，我們可以調用類的方法，包括重載的方法。反射調用遵循多態原則，總是調用實際類型的覆蓋方法。創建實例時，Constructor對象允許我們調用任何形式的構造函數，包括私有或帶有參數的構造。
反射機制還幫助我們查詢繼承關系，包括父類類型和實現的介面。通過isAssignableFrom()方法，我們可以判斷一個類型是否可以被另一個類型安全地向上轉型。
總的來說，反射是Java中的強大工具，盡管在常規開發中並不常用，但在特定場景和框架設計中發揮著不可替代的作用。它提供了一種在運行時動態探索和操作類結構的能力。
㈡ JAVA反射機製作用
一、什麼是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基於反射機制的語言。最近，反射機制也被應用到了視窗系統、操作系統和文件系統中。反射本身並不是一個新概念，盡管計算機科學賦予了反射概念新的含義。在計算機科學領域，反射是指一類應用，它們能夠自描述和自控制。也就是說，這類應用通過採用某種機制來實現對自己行為的描述（self-representation）和監測（examination），並能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。二、什麼是Java中的類反射：
Reflection 是 Java 程序開發語言的特徵之一，它允許運行中的 Java 程序對自身進行檢查，或者說「自審」，並能直接操作程序的內部屬性和方法。Java 的這一能力在實際應用中用得不是很多，但是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數定義相關的信息。
Reflection 是 Java 被視為動態（或准動態）語言的關鍵，允許程序於執行期 Reflection APIs 取得任何已知名稱之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可於執行期生成instances、變更 fields 內容或喚起 methods。三、Java類反射中所必須的類：
Java的類反射所需要的類並不多，它們分別是：Field、Constructor、Method、Class、Object，下面我將對這些類做一個簡單的說明。
Field類：提供有關類或介面的屬性的信息，以及對它的動態訪問許可權。反射的欄位可能是一個類（靜態）屬性或實例屬性，簡單的理解可以把它看成一個封裝反射類的屬性的類。
Constructor類：提供關於類的單個構造方法的信息以及對它的訪問許可權。這個類和Field類不同，Field類封裝了反射類的屬性，而Constructor類則封裝了反射類的構造方法。
Method類：提供關於類或介面上單獨某個方法的信息。所反映的方法可能是類方法或實例方法（包括抽象方法）。 這個類不難理解，它是用來封裝反射類方法的一個類。
Class類：類的實例表示正在運行的 Java 應用程序中的類和介面。枚舉是一種類，注釋是一種介面。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共享該 Class 對象。
Object類：每個類都使用 Object 作為超類。所有對象（包括數組）都實現這個類的方法。四、Java的反射類能做什麼：
看完上面的這么多我想你已經不耐煩了，你以為我在浪費你的時間，那麼好吧！下面我們就用一些簡單的小例子來說明它。
首先我們來看一下通過Java的反射機制我們能得到些什麼。
首先我們來寫一個類：java 代碼
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
class A extends Object implements ActionListener{
private int a = 3;
public Integer b = new Integer(4);
public A(){}
public A(int id,String name){}
public int abc(int id,String name){return 0;}
public void actionPerformed(ActionEvent e){}
} 你可能被我這個類弄糊塗了，你看不出我要做什麼，那就不要看這個類了，這個類是用來測試的，你知道知道它繼承了Object類，有一個介面是ActionListener，兩個屬性int和Integer,兩個構造方法和兩個方法，這就足夠了。
下面我們把A這個類作為一個反射類，來過去A類中的一些信息，首先我們先來過去一下反射類中的屬性和屬性值。java 代碼
import java.lang.reflect.*;
class B{
public static void main(String args[]){
A r = new A();
Class temp = r.getClass();
try{
System.out.println("反射類中所有公有的屬性");
Field[] fb =temp.getFields();
for(int j=0;j<fb.length;j++){
Class cl = fb[j].getType();
System.out.println("fb:"+cl);
}
System.out.println("反射類中所有的屬性");
Field[] fa = temp.getDeclaredFields();
for(int j=0;j<fa.length;j++){
Class cl = fa[j].getType();
System.out.println("fa:"+cl);
}
System.out.println("反射類中私有屬性的值");
Field f = temp.getDeclaredField("a");
f.setAccessible(true);
Integer i = (Integer)f.get(r);
System.out.println(i);
}catch(Exception e){
e.printStackTrace();
}
}
} 這里用到了兩個方法，getFields()、getDeclaredFields()，它們分別是用來獲取反射類中所有公有屬性和反射類中所有的屬性的方法。另外還有getField(String)和getDeclaredField(String)方法都是用來過去反射類中指定的屬性的方法，要注意的是getField方法只能取到反射類中公有的屬性，而getDeclaredField方法都能取到。
這里還用到了Field 類的setAccessible方法，它是用來設置是否有許可權訪問反射類中的私有屬性的，只有設置為true時才可以訪問，默認為false。另外 Field類還有set(Object AttributeName,Object value)方法，可以改變指定屬性的值。下面我們來看一下如何獲取反射類中的構造方法java 代碼
import java.lang.reflect.*;
public class SampleConstructor {
public static void main(String[] args) {
A r = new A();
printConstructors(r);
}
public static void printConstructors(A r) {
Class c = r.getClass();
//獲取指定類的類名
String className = c.getName();
try {
//獲取指定類的構造方法
Constructor[] theConstructors = c.getConstructors();
for(int i=0; i<theConstructors.length; i++) {
//獲取指定構造方法的參數的集合
Class[] parameterTypes = theConstructors[i].getParameterTypes();
System.out.print(className + "(");
for(int j=0; j<parameterTypes.length; j++)
System.out.print(parameterTypes[j].getName() + " ");
System.out.println(")");
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
這個例子很簡單,只是用getConstructors()方法獲取了反射類的構造方法的集合，並用Constructor類的getParameterTypes()獲取該構造方法的參數。下面我們再來獲取一下反射類的父類（超類）和介面java 代碼
import java.io.*;
import java.lang.reflect.*;
public class SampleInterface {
public static void main(String[] args) throws Exception {
A raf = new A();
printInterfaceNames(raf);
}
public static void printInterfaceNames(Object o) {
Class c = o.getClass();
//獲取反射類的介面
Class[] theInterfaces = c.getInterfaces();
for(int i=0; i<theInterfaces.length; i++)
System.out.println(theInterfaces[i].getName());
//獲取反射類的父類（超類）
Class theSuperclass = c.getSuperclass();
System.out.println(theSuperclass.getName());
}
} 這個例子也很簡單，只是用Class類的getInterfaces()方法獲取反射類的所有介面，由於介面可以有多個，所以它返回一個 Class數組。用getSuperclass()方法來獲取反射類的父類（超類），由於一個類只能繼承自一個類，所以它返回一個Class對象。下面我們來獲取一下反射類的方法java 代碼
import java.lang.reflect.*;
public class SampleMethod {
public static void main(String[] args) {
A p = new A();
printMethods(p);
}
public static void printMethods(Object o) {
Class c = o.getClass();
String className = c.getName();
Method[] m = c.getMethods();
for(int i=0; i<m.length; i++) {
//輸出方法的返回類型
System.out.print(m[i].getReturnType().getName());
//輸出方法名
System.out.print(" "+m[i].getName()+"(");
//獲取方法的參數
Class[] parameterTypes = m[i].getParameterTypes();
for(int j=0; j<parameterTypes.length; j++){
System.out.print(parameterTypes[j].getName());
if(parameterTypes.length>j+1){
System.out.print(",");
}
}
System.out.println(")");
}
}
} 這個例子並不難，它只是獲得了反射類的所有方法，包括繼承自它父類的方法。然後獲取方法的返回類型、方法名和方法參數。接下來讓我們回過頭來想一想，我們獲取了反射類的屬性、構造方法、父類、介面和方法，可這些東西能幫我們做些什麼呢！！
下面我寫一個比較完整的小例子，來說明Java的反射類能做些什麼吧！！java 代碼
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class LoadMethod {
public Object Load(String cName,String MethodName,String[] type,String[] param){
Object retobj = null;
try {
//載入指定的Java類
Class cls = Class.forName(cName);
//獲取指定對象的實例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//構建方法參數的數據類型
Class partypes[] = this.getMethodClass(type);
//在指定類中獲取指定的方法
Method meth = cls.getMethod(MethodName, partypes);
//構建方法的參數值
Object arglist[] = this.getMethodObject(type,param);
//調用指定的方法並獲取返回值為Object類型
retobj= meth.invoke(obj, arglist);
}
catch (Throwable e) {
System.err.println(e);
}
return retobj;
}
//獲取參數類型Class[]的方法
public Class[] getMethodClass(String[] type){
Class[] cs = new Class[type.length];
for (int i = 0; i < cs.length; i++) {
if(!type[i].trim().equals("")||type[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
cs[i]=Integer.TYPE;
}else if(type[i].equals("float")||type[i].equals("Float")){
cs[i]=Float.TYPE;
}else if(type[i].equals("double")||type[i].equals("Double")){
cs[i]=Double.TYPE;
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
cs[i]=Boolean.TYPE;
}else{
cs[i]=String.class;
}
}
}
return cs;
}
//獲取參數Object[]的方法
public Object[] getMethodObject(String[] type,String[] param){
Object[] obj = new Object[param.length];
for (int i = 0; i < obj.length; i++) {
if(!param[i].trim().equals("")||param[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
obj[i]= new Integer(param[i]);
}else if(type[i].equals("float")||type[i].equals("Float")){
obj[i]= new Float(param[i]);
}else if(type[i].equals("double")||type[i].equals("Double")){
obj[i]= new Double(param[i]);
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
obj[i]=new Boolean(param[i]);
}else{
obj[i] = param[i];
}
}
}
return obj;
}
} 這是我在工作中寫的一個實現Java在運行時載入指定的類，並調用指定方法的一個小例子。這里沒有main方法，你可以自己寫一個。
Load方法接收的五個參數分別是，Java的類名，方法名，參數的類型和參數的值。結束語：
Java語言反射提供一種動態鏈接程序組件的多功能方法。它允許程序創建和控制任何類的對象，無需提前硬編碼目標類。這些特性使得反射特別適用於創建以非常普通的方式與對象協作的庫。Java reflection 非常有用，它使類和數據結構能按名稱動態檢索相關信息，並允許在運行著的程序中操作這些信息。Java 的這一特性非常強大，並且是其它一些常用語言，如 C、C++、Fortran 或者 Pascal 等都不具備的。但反射有兩個缺點。第一個是性能問題。用於欄位和方法接入時反射要遠慢於直接代碼。性能問題的程度取決於程序中是如何使用反射的。如果它作為程序運行中相對很少涉及的部分，緩慢的性能將不會是一個問題。即使測試中最壞情況下的計時圖顯示的反射操作只耗用幾微秒。僅反射在性能關鍵的應用的核心邏輯中使用時性能問題才變得至關重要。
㈢ Java中為什麼反射機制中的屬性的類型是Class類型的 方式機制中那麼哪些東西是Class類型的呢
不是類型，Class在java.lang 同過不同的方法（4種）來動態的獲取你所需要的類或介面，動態也就是說事先你並不清楚要使用哪個類，而且提供路徑（String類型參數）可以獲得任何類或介面。返回一個Class類型，最後返回你想要的類型，常見與資料庫連接工廠Class c=Class.forName(name);DBConnection con=(DBConnection) c.newInstance();下面詳細的介紹一下 JAVA反射機制
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。
Java反射機制主要提供了以下功能： 在運行時判斷任意一個對象所屬的類；在運行時構造任意一個類的對象；在運行時判斷任意一個類所具有的成員變數和方法；在運行時調用任意一個對象的方法；生成動態代理。
1. 得到某個對象的屬性
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2 Class ownerClass = owner.getClass();
3
4 Field field = ownerClass.getField(fieldName);
5
6 Object property = field.get(owner);
7
8 return property;
9 }
Class ownerClass = owner.getClass()：得到該對象的Class。
Field field = ownerClass.getField(fieldName)：通過Class得到類聲明的屬性。
Object property = field.get(owner)：通過對象得到該屬性的實例，如果這個屬性是非公有的，這里會報IllegalAccessException。
2. 得到某個類的靜態屬性
1 public Object getStaticProperty(String className, String fieldName)
2 throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Field field = ownerClass.getField(fieldName);
6
7 Object property = field.get(ownerClass);
8
9 return property;
10 }
Class ownerClass = Class.forName(className) ：首先得到這個類的Class。
Field field = ownerClass.getField(fieldName)：和上面一樣，通過Class得到類聲明的屬性。
Object property = field.get(ownerClass) ：這里和上面有些不同，因為該屬性是靜態的，所以直接從類的Class里取。
3. 執行某對象的方法
1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3 Class ownerClass = owner.getClass();
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先還是必須得到這個對象的Class。
5～9行：配置參數的Class數組，作為尋找Method的條件。
Method method = ownerClass.getMethod(methodName, argsClass)：通過Method名和參數的Class數組得到要執行的Method。
method.invoke(owner, args)：執行該Method，invoke方法的參數是執行這個方法的對象，和參數數組。返回值是Object，也既是該方法的返回值。
4. 執行某個類的靜態方法
1 public Object invokeStaticMethod(String className, String methodName,
2 Object[] args) throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(null, args);
14 }
基本的原理和實例3相同，不同點是最後一行，invoke的一個參數是null，因為這是靜態方法，不需要藉助實例運行。
5. 新建實例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3 Class newoneClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Constructor cons = newoneClass.getConstructor(argsClass);
12
13 return cons.newInstance(args);
14
15 }
這里說的方法是執行帶參數的構造函數來新建實例的方法。如果不需要參數，可以直接使用newoneClass.newInstance()來實現。
Class newoneClass = Class.forName(className)：第一步，得到要構造的實例的Class。
第5～第9行：得到參數的Class數組。
Constructor cons = newoneClass.getConstructor(argsClass)：得到構造子。
cons.newInstance(args)：新建實例。
6. 判斷是否為某個類的實例
1 public boolean isInstance(Object obj, Class cls) {
2 return cls.isInstance(obj);
3 }
7. 得到數組中的某個元素
1 public Object getByArray(Object array, int index) {
2 return Array.get(array,index);
3 }