java的反射原理
A. java反射機制的實現原理
反射機制就是java語言在運行時擁有一項自觀的能力。
通過這種能力可以徹底的了解自身的情況為下一步的動作做准備。
下面具體介紹一下java的反射機制。這里你將顛覆原來對java的理解。
Java的反射機制的實現要藉助於4個類：class，Constructor，Field，Method；
其中class代表的時類對象，
Constructor－類的構造器對象，
Field－類的屬性對象，
Method－類的方法對象。
通過這四個對象我們可以粗略的看到一個類的各個組成部分。
Class：程序運行時，java運行時系統會對所有的對象進行運行時類型的處理。
這項信息記錄了每個對象所屬的類，虛擬機通常使用運行時類型信息選擇正 確的方法來執行（摘自：白皮書）。
但是這些信息我們怎麼得到啊，就要藉助於class類對象了啊。
在Object類中定義了getClass()方法。我 們可以通過這個方法獲得指定對象的類對象。然後我們通過分析這個對象就可以得到我們要的信息了。
比如：ArrayList arrayList;
Class clazz = arrayList.getClass();
然後我來處理這個對象clazz。
當然了Class類具有很多的方法，這里重點將和Constructor，Field，Method類有關系的方法。
Reflection 是 Java 程序開發語言的特徵之一，它允許運行中的 Java 程序對自身進行檢查，或者說「自審」，並能直接操作程序的內部屬性。Java 的這一能力在實際應用中也許用得不是很多，但是個人認為要想對java有個更加深入的了解還是應該掌握的。
reflection的工作機制
考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
//forName("java.lang.String")獲取指定的類的對象
Class c = Class.forName("java.lang.String");
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.ArrayList
這個程序使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。
Java類反射中的主要方法
對於以下三類組件中的任何一類來說
-- 構造函數、欄位和方法
-- java.lang.Class 提供四種獨立的反射調用，以不同的方式來獲得信息。調用都遵循一種標准格式。以下是用於查找構造函數的一組反射調用：
Constructor getConstructor(Class[] params) -- 獲得使用特殊的參數類型的公共構造函數，
Constructor[] getConstructors() -- 獲得類的所有公共構造函數
Constructor getDeclaredConstructor(Class[] params) -- 獲得使用特定參數類型的構造函數(與接入級別無關)
Constructor[] getDeclaredConstructors() -- 獲得類的所有構造函數(與接入級別無關)
獲得欄位信息的Class 反射調用不同於那些用於接入構造函數的調用，在參數類型數組中使用了欄位名：
Field getField(String name) -- 獲得命名的公共欄位
Field[] getFields() -- 獲得類的所有公共欄位
Field getDeclaredField(String name) -- 獲得類聲明的命名的欄位
Field[] getDeclaredFields() -- 獲得類聲明的所有欄位
用於獲得方法信息函數：
Method getMethod(String name, Class[] params) -- 使用特定的參數類型，獲得命名的公共方法
Method[] getMethods() -- 獲得類的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特寫的參數類型，獲得類聲明的命名的方法
Method[] getDeclaredMethods() -- 獲得類聲明的所有方法
使用 Reflection：
用於 reflection 的類，如 Method，可以在 java.lang.relfect 包中找到。使用這些類的時候必須要遵循三個步驟：
第一步是獲得你想操作的類的 java.lang.Class 對象。
在運行中的 Java 程序中，用 java.lang.Class 類來描述類和介面等。
下面就是獲得一個 Class 對象的方法之一：
Class c = Class.forName("java.lang.String");
這條語句得到一個 String 類的類對象。還有另一種方法，如下面的語句：
Class c = int.class;
或者
Class c = Integer.TYPE;
它們可獲得基本類型的類信息。其中後一種方法中訪問的是基本類型的封裝類 (如 Intege ) 中預先定義好的 TYPE 欄位。
第二步是調用諸如 getDeclaredMethods 的方法，以取得該類中定義的所有方法的列表。
一旦取得這個信息，就可以進行第三步了——使用 reflection API 來操作這些信息，如下面這段代碼：
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它將以文本方式列印出 String 中定義的第一個方法的原型。
處理對象：
a.創建一個Class對象
b.通過getField 創建一個Field對象
c.調用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對象就省略；Object是指實例).
例如：
import java.lang.reflect.*;
import java.awt.*;
class SampleGet {
public static void main(String[] args) throws Exception {
Rectangle r = new Rectangle(100, 325);
printHeight(r);
printWidth( r);
}
static void printHeight(Rectangle r)throws Exception {
//Field屬性名
Field heightField;
//Integer屬性值
Integer heightValue;
//創建一個Class對象
Class c = r.getClass();
//.通過getField 創建一個Field對象
heightField = c.getField("height");
//調用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對象就省略；Object是指實例).
heightValue = (Integer) heightField.get(r);
System.out.println("Height: " + heightValue.toString());
}
static void printWidth(Rectangle r) throws Exception{
Field widthField;
Integer widthValue;
Class c = r.getClass();
widthField = c.getField("width");
widthValue = (Integer) widthField.get(r);
System.out.println("Height: " + widthValue.toString());
}
}
B. Java中的反射機制的原理和用途是什麼
反射技術：其實就是動態載入一個指定的類，並獲取該類中的所有的內容。並將位元組碼文件中的內容都封裝成對象，這樣便於操作這些成員。簡單說：反射技術可以對一個類進行解剖。
反射的好處：大大地增強了程序的擴展性。
反射的基本步驟：
1、獲得Class對象，就是獲取到指定的名稱的位元組碼文件對象。
2、實例化對象，獲得類的屬性、方法或構造函數。
3、訪問屬性、調用方法、調用構造函數創建對象。
獲取這個Class對象，有三種方式：
1：通過每個對象都具備的方法getClass來獲取。弊端：必須要創建該類對象，才可以調用getClass方法。
2：每一個數據類型(基本數據類型和引用數據類型)都有一個靜態的屬性class。弊端：必須要先明確該類。
前兩種方式不利於程序的擴展，因為都需要在程序使用具體的類來完成。
3：使用的Class類中的方法，靜態的forName方法。
C. Java裡面反射的原理是什麼
java虛擬機運行時內存有個叫方法區，主要作用是存儲被裝載的類的類型信息。每裝載一個類的時候，java就會創建一個該類的Class對象實例。我們就可以通過這個實例，來訪問這個類的信息。
D. Java的反射機制是什麼，如何實現
Java中的反射機制，通俗點解釋就是能夠在程序運行中動態獲取到內存中任一對象的信息，這些信息包括對象所屬類、類中的方法和屬性、以及它們的訪問控制域和返回值類型等等，還可以通過反射動態調用對象中的方法，而不管該方法的訪問域是私有或是公開，包括構造方法，還能實現動態代理等。總之，反射能夠破壞掉JAVA類本身的封裝性，進而獲取其私有的或公開的信息，也就能突破封裝進而調用私有的或公開的方法。
實現的話就是通過反射介面，JAVA把反射相關的類介面都封裝在了java.lang.reflect這個包中，你可以研究下這個包中的類，對於類的每一個屬性，如變數、方法，構造方法，這個包中都就與之相對應的類，通過這個類就可以操作這個屬性了。
java反射很強大，但也很危險，在實際開發中應少用或不用，在必要用之時，往往也能解決你遇到的問題。
E. java，反射機制
你這個還不是反射，這個叫強制類型轉換。 因為己經知道myProxy.getProxy方法返回的類型肯定是 TargetInterface 類型，所以(TargetInterface)myProxy.getProxy肯定沒有問題。
同時，TargetInterface 繼承自 Object 所以編譯也是正確的。
那麼真正的反射是利用類的包名直接實例化出類的對象實例，以下是類反射的一個例子：
Class<?> cls= Class.forName(「com.app.TargetInterface」);
if(cls!=null){
try {
TargetInterface interface=(TargetInterface)cls.newInstance();
} catch (Exception e) {}
}
這樣，只要傳給一個字元串，就可以把一個類構建出對象來。
本例中構建出來的是採用該類的默認構造函數， 還可以指定構造器。
甚至利用類反射可以分析出類結構中所有的方法和屬性。
利用類反射機制可以製造計算機病毒。
具體更多的類反射知識可以詳見專門介紹此知識的書籍
F. java反射機制
意思類知道自己有什麼方法，有什麼屬性，，不僅知道，，運行的時候我還可以調用我自己的屬性方法，，這就是你要問的
G. java反射的理解
簡單的話就是根據一個類名，把類里的構造器啊，方法啊，屬性啊什麼的都可以得到。InvocationHandler這個是真沒用過
H. java的反射機制原理和作用
作用：補充語言不完善的地方。
機制：Unsafe和代碼生成。
建議：不用太深入，不過貌似也沒有什麼好什麼的。及時跟進InvokeDynamic和Lambda！
I. java中的反射機制是什麼，有什麼作用啊
Method類中的方法的使用（含代碼和注釋）：
getMethods()獲得本類及父類中的public許可權修飾**符方法
getDeclaredMethods()專門獲得調用該方法的對象的本類中的所有方法包括private許可權修飾符**的方法
getDeclaredMethod(Stringname,class<?>...parameterTypes)
第一個參數：方法的名稱
第二個參數：可變長度，寫你要查找的那個方法的參數類型列表.class
getParameterCount()得到方法的參數個數123456
packageLessonForReflection03;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;abstractclassCard{
privatevoidcreatRandomNumbers(intcount)//private關鍵字
{
}
publicvoidgetFullCardsNumbers(String[]random,Stringpre_numbers)
{
}
publicstaticvoidgetUserInfor()
{
}
(Stringtel);
(intsal1,intsal2),ArithmeticException;}publicclassMethodInforGetter{
publicstaticvoidmain(String[]args)
{
Class<?>c1=Card.class;
System.out.println("-------------------------");
Method[]m1=c1.getMethods();//getMethods()獲得本類及父類中的public方法！
for(Methodm:m1)
{
System.out.println(m);
}
System.out.println("-------------------------");
Method[]m2=c1.getDeclaredMethods();//getDeclaredMethods()專門獲得本類中的所有方法包括private！
for(Methodm:m2)
{
System.out.println(m);
}
System.out.println("-------------------------");
/*
*getDeclaredMethod(Stringname,class<?>...parameterTypes)
*第一個參數：方法的名稱
*第二個參數：可變長度，寫你要查找的那個方法的參數類型列表
*
*getParameterCount()得到方法的參數個數
*/
try
{
Methodm3=c1.getDeclaredMethod("getUserInfor");
System.out.println(m3);
//getParameterCount()方法,獲得方法參數個數
System.out.println(m3.getParameterCount());
System.out.println(Modifier.toString(m3.getModifiers()));//獲得方法修飾符
System.out.println(m3.getReturnType());
System.out.println("-------------------------");
Methodm4=c1.getDeclaredMethod("getUserInfor",int.class,int.class);
//getExceptionTypes()可以獲得初始化當前Method對象的給Class對象初始化的那個類的那個指定方法拋出的異常類型
Class<?>[]exception=m4.getExceptionTypes();
for(Class<?>e:exception)
{
System.out.println(e);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}576777879808182838485868788
Constructor類中的方法的使用www.xiaoyuani.com（含代碼和注釋）：
java.lang.reflect.Constructor:
Constructor[]getConstructor()獲得本類里的public許可權修飾符構造函數，不能獲取父類的！
Constructor[]getDeclaredConstructor()獲得本類中的所以構造函數！
Constructor<T>getConstructor(Class...parameterType)用參數決定獲得本類中的某個的構造方法,只能獲得public的
Constructor<T>getDeclaredConstructor(Class...parameterType)用參數決定獲得本類中的某個構造方法
附：
JDK8.0之後新增的類：
Executable：
它是Method和Constructor的父類
常用方法：
getParameter()獲得類中方法參數
getExceptionTypes()獲得類中某個方法拋出異常類型
getMoidfiers()獲得方法許可權修飾符
Parameter:
封裝並代表了參數實例123456789101112131415
packageLessonForReflection03;importjava.lang.reflect.Constructor;importjava.lang.reflect.Modifier;importjava.lang.reflect.Parameter;/*
*java.lang.reflect.Constructor
*
*Constructor[]getConstructor();獲得本類里的public許可權修飾符構造函數，不能獲取父類的
*Constructor[]getDeclaredConstructor();得本類里的全部構造
*
*Constructor<T>getConstructor(Class...parameterType);用參數決定獲得哪個構造方法
*Constructor<T>getDeclaredConstructor(Class...parameterType);
*
*/{
publicstaticvoidmain(String[]args)
{
System.out.println("獲得Cricle本類里的public許可權修飾符構造函數，不能獲取父類的Constructor[]getConstructor()");
System.out.println("子類繼承不了父類中的構造方法和private");
//Constructor[]getConstructor()獲得Cricle本類里的public許可權修飾符構造函數，不能獲取父類的
//子類繼承不了父類中的構造方法和private
Class<Circle>c1=Circle.class;
Constructor<?>[]cons1=c1.getConstructors();
for(Constructor<?>cons:cons1)
{
System.out.println(cons);
//System.out.println(cons.getName());
}
System.out.println("-----------------------");
System.out.println("方法獲得本類中的所有構造函數getDeclaredConstructor()");
Constructor<?>[]cons2=c1.getDeclaredConstructors();
for(Constructor<?>cons:cons2)
{
System.out.println(cons);
}
System.out.println("-----------------------");
try
{
System.out.println("方法用參數指定獲得本類！構造方法,只能獲取public的Constructor<T>getConstructor(Class...parameterType)");
Constructor<?>cons3=c1.getConstructor(int.class);
System.out.println(Modifier.toString(cons3.getModifiers()));
System.out.println(cons3);
System.out.println("-----------------------");
System.out.println("方法用參數指定獲得本類！構造方法任何許可權修飾符的都可以獲得Constructor<T>getDeclaredConstructor(Class...parameterType)");
Constructor<?>cons4=c1.getDeclaredConstructor(String.class);
System.out.println(cons4);
System.out.println("-----------------------");
/*
*JDK8.0之後新增的類
*Executable：
*是Method和Constructor的父類
*方法：
*getParameter();
*getExceptionTypes();
*getModifiers();
*getTypeParameters();
*
*Parameter:
*封裝並代表了參數實例
*/
System.out.println("獲取類中方法的參數getParameters()");
Constructor<?>cons5=c1.getDeclaredConstructor(int.class,String.class);
Parameter[]p1=cons5.getParameters();
for(Parameterp:p1)
{
System.out.println(p);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}5767778798081828384858687
代碼中提到的Circle類和Shape類二者為繼承關系：
packageLessonForReflection03;publicclassCircleextendsShape{
privateintr;
privateStringcolor;
publicCircle(intr,Stringcolor)
{
super();
this.r=r;
this.color=color;
}
publicCircle(intr)
{
super();
this.r=r;
}
protectedCircle(Stringcolor)
{
super();
this.color=color;
}
Circle()
{
super();
}}
packageLessonForReflection03;publicclassShape{
privateintper;
publicShape(intper)
{
super();
this.per=per;
}
publicShape()
{
super();
}}1234567891011121314151617
部分文字來源於：
咕嘟咖啡楊海濱老師 — 《java編程語言高級特性》
輕量化研習Java相關技術倡導者
「愛碼學院」聯合創始人自適應教學理念提出者踐行者；多年開發及項目管理經歷；出版《JavaEE企業級應用與開發》一書；10餘年高校項目實踐畢設指導經驗；企業軟培經驗豐富
J. java的反射機制是什麼
反射技術：其實就是動態載入一個指定的類，並獲取該類中的所有的內容。並將位元組碼文件中的內容都封裝成對象，這樣便於操作這些成員。簡單說：反射技術可以對一個類進行解剖。
反射的好處：大大的增強了程序的擴展性。
反射的基本步驟：
1、獲得Class對象，就是獲取到指定的名稱的位元組碼文件對象。
2、實例化對象，獲得類的屬性、方法或構造函數。
3、訪問屬性、調用方法、調用構造函數創建對象。