JAVA反射機制
A. java的反射機制是什麼，如何實現
Java中的反射機制，通俗點解釋就是能夠在程序運行中動態獲取到內存中任一對象的信息，這些信息包括對象所屬類、類中的方法和屬性、以及它們的訪問控制域和返回值類型等等，還可以通過反射動態調用對象中的方法，而不管該方法的訪問域是私有或是公開，包括構造方法，還能實現動態代理等。總之，反射能夠破壞掉JAVA類本身的封裝性，進而獲取其私有的或公開的信息，也就能突破封裝進而調用私有的或公開的方法。
實現的話就是通過反射介面，JAVA把反射相關的類介面都封裝在了java.lang.reflect這個包中，你可以研究下這個包中的類，對於類的每一個屬性，如變數、方法，構造方法，這個包中都就與之相對應的類，通過這個類就可以操作這個屬性了。
java反射很強大，但也很危險，在實際開發中應少用或不用，在必要用之時，往往也能解決你遇到的問題。
B. java反射機制
構造方法是無返回值類型的方法
還有一個是,類名要大寫,方法名要小寫
例如:
public class Test(){
public Test(){
//無參構造方法,沒有返回值類型,方法名必須與類名相同
}
public Test(int i){
//帶參構造方法,沒有返回值類型,方法名必須與類名相同
}
}
C. Java中的反射機制的原理和用途是什麼
反射技術：其實就是動態載入一個指定的類，並獲取該類中的所有的內容。並將位元組碼文件中的內容都封裝成對象，這樣便於操作這些成員。簡單說：反射技術可以對一個類進行解剖。
反射的好處：大大地增強了程序的擴展性。
反射的基本步驟：
1、獲得Class對象，就是獲取到指定的名稱的位元組碼文件對象。
2、實例化對象，獲得類的屬性、方法或構造函數。
3、訪問屬性、調用方法、調用構造函數創建對象。
獲取這個Class對象，有三種方式：
1：通過每個對象都具備的方法getClass來獲取。弊端：必須要創建該類對象，才可以調用getClass方法。
2：每一個數據類型(基本數據類型和引用數據類型)都有一個靜態的屬性class。弊端：必須要先明確該類。
前兩種方式不利於程序的擴展，因為都需要在程序使用具體的類來完成。
3：使用的Class類中的方法，靜態的forName方法。
D. 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());
}
}
E. java的反射機制是什麼
反射技術：其實就是動態載入一個指定的類，並獲取該類中的所有的內容。並將位元組碼文件中的內容都封裝成對象，這樣便於操作這些成員。簡單說：反射技術可以對一個類進行解剖。
反射的好處：大大的增強了程序的擴展性。
反射的基本步驟：
1、獲得Class對象，就是獲取到指定的名稱的位元組碼文件對象。
2、實例化對象，獲得類的屬性、方法或構造函數。
3、訪問屬性、調用方法、調用構造函數創建對象。
F. java的反射機制原理和作用
作用：補充語言不完善的地方。
機制：Unsafe和代碼生成。
建議：不用太深入，不過貌似也沒有什麼好什麼的。及時跟進InvokeDynamic和Lambda！
G. 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餘年高校項目實踐畢設指導經驗；企業軟培經驗豐富
H. 反射機制在java中如何做呀
首先大體介紹下反射機制：JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。 舉個簡單的列子 import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectTester { /** * 通過java的反射機制獲取類的所有屬性和方法 */ public void test1() { try { Class c = Class.forName("demo1.client.Customer"); System.out.println("屬性："); Field f[] = c.getDeclaredFields(); for (int i = 0; i < f.length; i++) { System.out.println(f[i].getName()); } System.out.println("方法："); 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的反射機制動態修改對象的屬性 * @param o */ public void test2(Customer o) { try { Class c = o.getClass(); //getMethod方法第一個參數指定一個需要調用的方法名稱，第二個參數是需要調用方法的參數類型列表，如無參數可以指定null，該方法返回一個方法對象 Method sAge = c.getMethod("setAge", new Class[] { int.class }); Method gAge = c.getMethod("getAge", null); Method sName = c.getMethod("setName", new Class[] { String.class }); //動態修改Customer對象的age Object[] args1 = { new Integer(25) }; sAge.invoke(o, args1); //動態取得Customer對象的age Integer AGE = (Integer) gAge.invoke(o, null); System.out.println("the Customer age is: " + AGE.intValue()); //動態修改Customer對象的name Object[] args2 = { new String("李四") }; sName.invoke(o, args2); } catch (Throwable e) { System.err.println(e); } } /** * 通過java的反射機製做一個簡單對象的克隆 * @param o * @return */ public Object test3(Customer o) { Object o2 = null; try { Class c = o.getClass(); //通過默認構造方法創建一個新的對象 o2 = c.getConstructor(new Class[] {}).newInstance( new Object[] {}); Field fields[] = c.getDeclaredFields(); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldName = field.getName(); String firstLetter = fieldName.substring(0, 1).toUpperCase(); // 獲得和屬性對應的getXXX()方法的名字 String getMethodName = "get" + firstLetter + fieldName.substring(1); // 獲得和屬性對應的setXXX()方法的名字 String setMethodName = "set" + firstLetter + fieldName.substring(1); // 獲得和屬性對應的getXXX()方法 Method getMethod = c.getMethod(getMethodName, new Class[] {}); // 獲得和屬性對應的setXXX()方法 Method setMethod = c.getMethod(setMethodName, new Class[] { field.getType() }); // 調用原對象的getXXX()方法 Object value = getMethod.invoke(o, new Object[] {}); // 調用拷貝對象的setXXX()方法 setMethod.invoke(o2, new Object[] { value }); } } catch (Throwable e) { System.err.println(e); } return o2; } public static void main(String[] args) throws Exception { ReflectTester t = new ReflectTester(); t.test1(); Customer customer = new Customer(); customer.setAge(20); customer.setName("張三"); System.out.println("調用前name: " + customer.getName()); System.out.println("調用前age: " + customer.getAge()); t.test2(customer); System.out.println("調用後name: " + customer.getName()); System.out.println("調用後age: " + customer.getAge()); Customer customer2 = (Customer)t.test3(customer); System.out.println("克隆對象的name: " + customer2.getName()); System.out.println("克隆對象的age: " + customer2.getAge()); } } class Customer { private long id; private String name; private int age; public Customer() { } public Customer(String name, int age) { this.name = name; this.age = age; } public long getId() { return id; } public void setId(long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } 你可以自己運行下看看，再修改一些看看
I. 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) {}
}
這樣，只要傳給一個字元串，就可以把一個類構建出對象來。
本例中構建出來的是採用該類的默認構造函數， 還可以指定構造器。
甚至利用類反射可以分析出類結構中所有的方法和屬性。
利用類反射機制可以製造計算機病毒。
具體更多的類反射知識可以詳見專門介紹此知識的書籍
J. Java 方法反射機制
1.保ation的值和方法名字一樣
2..if要調用的方法在同一個類裡面;
然後把你的if條件去掉,換成我這個代碼看看效果
Class c = Class.forName("包名.類名");
//或者是new 類().getClass()
Class partypes[] = new Class[2];
partypes[0]=HttpServletRequest.class;
partypes[1]=HttpServletResponse .class;
Method m = c.getDeclaredMethod(action, partypes);
Object arglist[] = new Object[2];
arglist[0] = request;
arglist[1] =response;
m.invoke(c.newInstance(),arglist)