導航:首頁 > 編程語言 > java反射修飾符

java反射修飾符

發布時間:2023-10-25 18:18:39

『壹』 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餘年高校項目實踐畢設指導經驗;企業軟培經驗豐富

『貳』 java中的反射機制是什麼有什麼作用呢求解,謝謝。

Java反射機制詳解

1. 反射機制是什麼

反射機制是在運行狀態中,對於任意一個類,都能夠知道這個類的所有屬性和方法;對於任意一個對象,都能夠調用它的任意一個方法和屬性;這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。

2. 反射機制能做什麼

反射機制主要提供了以下功能:

3. 反射機制的相關API

通過一個對象獲得完整的包名和類名

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
TestReflecttestReflect=newTestReflect();
System.out.println(testReflect.getClass().getName());
//結果net.xsoftlab.ke.TestReflect
}
}

實例化Class類對象

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
Class<?>class2=null;
Class<?>class3=null;
//一般採用這種形式
class1=Class.forName("net.xsoftlab.ke.TestReflect");
class2=newTestReflect().getClass();
class3=TestReflect.class;
System.out.println("類名稱"+class1.getName());
System.out.println("類名稱"+class2.getName());
System.out.println("類名稱"+class3.getName());
}
}

獲取一個對象的父類與實現的介面

packagenet.xsoftlab.ke;
importjava.io.Serializable;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//取得父類
Class<?>parentClass=clazz.getSuperclass();
System.out.println("clazz的父類為:"+parentClass.getName());
//clazz的父類為:java.lang.Object
//獲取所有的介面
Class<?>intes[]=clazz.getInterfaces();
System.out.println("clazz實現的介面有:");
for(inti=0;i<intes.length;i++){
System.out.println((i+1)+":"+intes[i].getName());
}
//clazz實現的介面有:
//1:java.io.Serializable
}
}

獲取某個類中的全部構造函數 - 詳見下例

通過反射機制實例化一個類的對象

packagenet.xsoftlab.ke;
importjava.lang.reflect.Constructor;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
class1=Class.forName("net.xsoftlab.ke.User");
//第一種方法,實例化默認構造方法,調用set賦值
Useruser=(User)class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
//結果User[age=20,name=Rollen]
//第二種方法取得全部的構造函數使用構造函數賦值
Constructor<?>cons[]=class1.getConstructors();
//查看每個構造方法需要的參數
for(inti=0;i<cons.length;i++){
Class<?>clazzs[]=cons[i].getParameterTypes();
System.out.print("cons["+i+"](");
for(intj=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//結果
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user=(User)cons[0].newInstance("Rollen");
System.out.println(user);
//結果User[age=0,name=Rollen]
user=(User)cons[1].newInstance(20,"Rollen");
System.out.println(user);
//結果User[age=20,name=Rollen]
}
}
classUser{
privateintage;
privateStringname;
publicUser(){
super();
}
publicUser(Stringname){
super();
this.name=name;
}
publicUser(intage,Stringname){
super();
this.age=age;
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"User[age="+age+",name="+name+"]";
}
}

獲取某個類的全部屬性

packagenet.xsoftlab.ke;
importjava.io.Serializable;
importjava.lang.reflect.Field;
importjava.lang.reflect.Modifier;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
System.out.println("===============本類屬性===============");
//取得本類的全部屬性
Field[]field=clazz.getDeclaredFields();
for(inti=0;i<field.length;i++){
//許可權修飾符
intmo=field[i].getModifiers();
Stringpriv=Modifier.toString(mo);
//屬性類型
Class<?>type=field[i].getType();
System.out.println(priv+""+type.getName()+""+field[i].getName()+";");
}

System.out.println("==========實現的介面或者父類的屬性==========");
//取得實現的介面或者父類的屬性
Field[]filed1=clazz.getFields();
for(intj=0;j<filed1.length;j++){
//許可權修飾符
intmo=filed1[j].getModifiers();
Stringpriv=Modifier.toString(mo);
//屬性類型
Class<?>type=filed1[j].getType();
System.out.println(priv+""+type.getName()+""+filed1[j].getName()+";");
}
}
}

通過反射機制調用某個類的方法

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//調用TestReflect類中的reflect1方法
Methodmethod=clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
//Java反射機制-調用某個類的方法1.
//調用TestReflect的reflect2方法
method=clazz.getMethod("reflect2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"張三");
//Java反射機制-調用某個類的方法2.
//age->20.name->張三
}
publicvoidreflect1(){
System.out.println("Java反射機制-調用某個類的方法1.");
}
publicvoidreflect2(intage,Stringname){
System.out.println("Java反射機制-調用某個類的方法2.");
System.out.println("age->"+age+".name->"+name);
}
}

通過反射機制操作某個類的屬性

packagenet.xsoftlab.ke;
importjava.lang.reflect.Field;
publicclassTestReflect{
privateStringproprety=null;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
Objectobj=clazz.newInstance();
//可以直接對private的屬性賦值
Fieldfield=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"Java反射機制");
System.out.println(field.get(obj));
}
}

4. 反射機制的應用實例

在泛型為Integer的ArrayList中存放一個String類型的對象。

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
ArrayList<Integer>list=newArrayList<Integer>();
Methodmethod=list.getClass().getMethod("add",Object.class);
method.invoke(list,"Java反射機制實例。");
System.out.println(list.get(0));
}
}

通過反射取得並修改數組的信息

packagenet.xsoftlab.ke;
importjava.lang.reflect.Array;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
int[]temp={1,2,3,4,5};
Class<?>demo=temp.getClass().getComponentType();
System.out.println("數組類型:"+demo.getName());
System.out.println("數組長度"+Array.getLength(temp));
System.out.println("數組的第一個元素:"+Array.get(temp,0));
Array.set(temp,0,100);
System.out.println("修改之後數組第一個元素為:"+Array.get(temp,0));
}
}

將反射機制應用於工廠模式

packagenet.xsoftlab.ke;
interfacefruit{
publicabstractvoideat();
}
classAppleimplementsfruit{
publicvoideat(){
System.out.println("Apple");
}
}
classOrangeimplementsfruit{
publicvoideat(){
System.out.println("Orange");
}
}
classFactory{
publicstaticfruitgetInstance(StringClassName){
fruitf=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch(Exceptione){
e.printStackTrace();
}
returnf;
}
}
/**
*對於普通的工廠模式當我們在添加一個子類的時候,就需要對應的修改工廠類。當我們添加很多的子類的時候,會很麻煩。
*Java工廠模式可以參考
*http://ke.xsoftlab.net/view/java-factory-pattern
*
*現在我們利用反射機制實現工廠模式,可以在不修改工廠類的情況下添加任意多個子類。
*
*但是有一點仍然很麻煩,就是需要知道完整的包名和類名,這里可以使用properties配置文件來完成。
*
*java讀取properties配置文件的方法可以參考
*http://ke.xsoftlab.net/view/java-read-the-properties-configuration-file
*
*@authorxsoftlab.net
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
fruitf=Factory.getInstance("net.xsoftlab.ke.Apple");
if(f!=null){
f.eat();
}
}
}
我有一個微信公眾號,經常會分享一些Java技術相關的干貨,還有一些學習資源。
如果你喜歡我的分享,可以用微信搜索「Java團長」或者「javatuanzhang」關注。

『叄』 說說對java反射的理解,使用反射如何獲取一個類的所有方法,使用反射需要注意哪些問題

反射說白了就是可以獲得一個類的所有信息,主要包括方法和屬性兩部分。
1.獲得方法包括獲得方法的名稱,方法的返回類型,方法的訪問修飾符,以及通過反射執行這個方法。
2.獲得屬性包括屬性的名稱,類型,訪問修飾符,以及這個屬性的值。
這些獲得都有相應的API提供操作。

舉個例子:
先定義一個類,有age這個屬性,以及age的get和set方法:

public class TestRflectionFather {
public int age =32;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

然後操作獲得所有方法:

import java.lang.reflect.Method;
public class Testmain {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("TestRflectionFather");
Method[] methods =clazz.getDeclaredMethods();
for(Method me:methods)
{
System.out.println(me.getName());
}
}

}

//最後輸出
getAge
setAge

『肆』 Java反射 getFields和getDeclaredFields的區別

關於獲取類的欄位有兩種方式:getFields()和getDeclaredFields()。我們先來看看這兩者的區別吧:



具體編碼如下:

我們先創建一個POJO

publicclassUser{
privatelongid;
privateStringname;

publicvoidsetId(longid){
this.id=id;
}

publicvoidsetName(Stringname){
this.name=name;
}

publiclonggetId(){
returnid;
}

publicStringgetName(){
returnname;
}
}

再來獲取此類中的所有欄位

Field[]fields=User.class.getDeclaredFields();

獲取欄位的名稱

StringfieldName=field.getName();

獲取欄位的修飾符

intfieldValue=field.getModifiers();//如:private、static、final等

與某個具體的修飾符進行比較

Modifier.isStatic(fieldValue)//看此修飾符是否為靜態(static)

獲取欄位的聲明類型

field.getType();//返回的是一個class

與某個類型進行比較

field.getType()==Timestamp.class

獲取指定對象中此欄位的值

ObjectfieldObject=field.get(user);//user可以看做是從資料庫中查找出來的對象

『伍』 Java Reflection (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有個更加深入的了解還是應該掌握的。

1.檢測類:

reflection的工作機制

考慮下面這個簡單的例子,讓我們看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

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) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

}

}

安全性和反射:

在處理反射時安全性是一個較復雜的問題。反射經常由框架型代碼使用,由於這一點,我們可能希望框架能夠全面接入代碼,無需考慮常規的接入限制。但是,在其它情況下,不受控制的接入會帶來嚴重的安全性風險,例如當代碼在不值得信任的代碼共享的環境中運行時。

由於這些互相矛盾的需求,Java編程語言定義一種多級別方法來處理反射的安全性。基本模式是對反射實施與應用於源代碼接入相同的限制:

從任意位置到類公共組件的接入

類自身外部無任何到私有組件的接入

受保護和打包(預設接入)組件的有限接入

不過至少有些時候,圍繞這些限制還有一種簡單的方法。我們可以在我們所寫的類中,擴展一個普通的基本類 java.lang.reflect.AccessibleObject 類。這個類定義了一種setAccessible方法,使我們能夠啟動或關閉對這些類中其中一個類的實例的接入檢測。唯一的問題在於如果使用了安全性管理 器,它將檢測正在關閉接入檢測的代碼是否許可了這樣做。如果未許可,安全性管理器拋出一個例外。

下面是一段程序,在TwoString 類的一個實例上使用反射來顯示安全性正在運行:

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

}

}

如果我們編譯這一程序時,不使用任何特定參數直接從命令行運行,它將在field .get(inst)調用中拋出一個IllegalAccessException異常。如果我們不注釋 field.setAccessible(true)代碼行,那麼重新編譯並重新運行該代碼,它將編譯成功。最後,如果我們在命令行添加了JVM參數 -Djava.security.manager以實現安全性管理器,它仍然將不能通過編譯,除非我們定義了ReflectSecurity類的許可權 限。

反射性能:(轉錄別人的啊)

反射是一種強大的工具,但也存在一些不足。一個主要的缺點是對性能有影響。使用反射基本上是一種解釋操作,我們可以告訴JVM,我們希望做什麼並且它滿足我們的要求。這類操作總是慢於只直接執行相同的操作。

下面的程序是欄位接入性能測試的一個例子,包括基本的測試方法。每種方法測試欄位接入的一種形式 -- accessSame 與同一對象的成員欄位協作,accessOther 使用可直接接入的另一對象的欄位,accessReflection 使用可通過反射接入的另一對象的欄位。在每種情況下,方法執行相同的計算 -- 循環中簡單的加/乘順序。

程序如下:

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index < loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index < loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index < loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

}

在上面的例子中,測試程序重復調用每種方法,使用一個大循環數,從而平均多次調用的時間衡量結果。平均值中不包括每種方法第一次調用的時間,因此初始化時間不是結果中的一個因素。下面的圖清楚的向我們展示了每種方法欄位接入的時間:

圖 1:欄位接入時間 :

我們可以看出:在前兩副圖中(Sun JVM),使用反射的執行時間超過使用直接接入的1000倍以上。通過比較,IBM JVM可能稍好一些,但反射方法仍舊需要比其它方法長700倍以上的時間。任何JVM上其它兩種方法之間時間方面無任何顯著差異,但IBM JVM幾乎比Sun JVM快一倍。最有可能的是這種差異反映了Sun Hot Spot JVM的專業優化,它在簡單基準方面表現得很糟糕。反射性能是Sun開發1.4 JVM時關注的一個方面,它在反射方法調用結果中顯示。在這類操作的性能方面,Sun 1.4.1 JVM顯示了比1.3.1版本很大的改進。

如果為為創建使用反射的對象編寫了類似的計時測試程序,我們會發現這種情況下的差異不象欄位和方法調用情況下那麼顯著。使用newInstance()調 用創建一個簡單的java.lang.Object實例耗用的時間大約是在Sun 1.3.1 JVM上使用new Object()的12倍,是在IBM 1.4.0 JVM的四倍,只是Sun 1.4.1 JVM上的兩部。使用Array.newInstance(type, size)創建一個數組耗用的時間是任何測試的JVM上使用new type[size]的兩倍,隨著數組大小的增加,差異逐步縮小。隨著jdk6.0的推出,反射機制的性能也有了很大的提升。期待中….

總結:

Java語言反射提供一種動態鏈接程序組件的多功能方法。它允許程序創建和控制任何類的對象(根據安全性限制),無需提前硬編碼目標類。這些特性使得反射 特別適用於創建以非常普通的方式與對象協作的庫。例如,反射經常在持續存儲對象為資料庫、XML或其它外部格式的框架中使用。Java reflection 非常有用,它使類和數據結構能按名稱動態檢索相關信息,並允許在運行著的程序中操作這些信息。Java 的這一特性非常強大,並且是其它一些常用語言,如 C、C++、Fortran 或者 Pascal 等都不具備的。

但反射有兩個缺點。第一個是性能問題。用於欄位和方法接入時反射要遠慢於直接代碼。性能問題的程度取決於程序中是如何使用反射的。如果它作為程序運行中相 對很少涉及的部分,緩慢的性能將不會是一個問題。即使測試中最壞情況下的計時圖顯示的反射操作只耗用幾微秒。僅反射在性能關鍵的應用的核心邏輯中使用時性 能問題才變得至關重要。

許多應用中更嚴重的一個缺點是使用反射會模糊程序內部實際要發生的事情。程序人員希望在源代碼中看到程序的邏輯,反射等繞過了源代碼的技術會帶來維護問 題。反射代碼比相應的直接代碼更復雜,正如性能比較的代碼實例中看到的一樣。解決這些問題的最佳方案是保守地使用反射——僅在它可以真正增加靈活性的地方 ——記錄其在目標類中的使用。

一下是對應各個部分的例子:

具體的應用:

1、 模仿instanceof 運算符號

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

2、 在類中尋找指定的方法,同時獲取該方法的參數列表,例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

3、 獲取類的構造函數信息,基本上與獲取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

4、 獲取類中的各個數據成員對象,包括名稱。類型和訪問修飾符號

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

5、 通過使用方法的名字調用方法

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

}

}

6、 創建新的對象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

7、 變更類實例中的數據的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

使用反射創建可重用代碼:

1、 對象工廠

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

}

2、 動態檢測對象的身份,替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

『陸』 Java的反射到底有什麼用途

反射的作用可謂是博大精深,

  1. JDK動態代理生成代理類的位元組碼後,首先把這個類通過defineclass定義成一個類,然後用class.for(name)會把該類載入到jvm,之後我們就可以通過,A.class.GetMethod()獲取其方法,然後通過invoke調用其方法,在調用這個方法時,實際上會通過被代理類的引用再去調用原方法。

  2. Java反射包reflection提供對Class,Method,field,constructor1 等信息的封裝類型

  3. 通過這些api可以輕易獲得一個類的各種信息並且可以進行實例化,方法調用等。
    類中的private參數可以通過setaccessible方法強制獲取。

閱讀全文

與java反射修飾符相關的資料

熱點內容
銀行人員如何解壓 瀏覽:829
newfile命令快捷鍵 瀏覽:567
阿里雲物理伺服器 瀏覽:953
靈狐視頻app哪個好 瀏覽:257
大廠退役程序員自述 瀏覽:252
linux命令watch 瀏覽:889
加密幣哪些平台不撤出中國 瀏覽:553
max加線命令 瀏覽:424
app胖瘦模式哪個好用 瀏覽:724
可以下載源碼的軟體 瀏覽:487
程序員寫一天代碼累嗎 瀏覽:628
ie文件夾禁止訪問 瀏覽:545
百川互聯網程序員 瀏覽:785
linuxpython解釋器 瀏覽:669
興安得力軟體加密狗 瀏覽:494
智能網路攝像頭加密 瀏覽:575
軟體畢業程序員培訓 瀏覽:654
安卓陀螺儀低怎麼辦 瀏覽:248
一級建造師復習題集pdf 瀏覽:905
法理學pdf海默 瀏覽:394