Java反射機制

說到反射，相信有過編程經驗的人都不會陌生。反射機制讓Java變得更加的靈活。反射機制在Java的眾多特性中是非常重要的一個。下面就讓我們一點一點了解它是怎么一回事。

什么是反射

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

反射有什么用

1，在運行時判斷任意一個對象所屬的類；

2，在運行時構造任意一個類的對象；

3，在運行時判斷任意一個類所具有的成員變量和方法；

4，在運行時調用任意一個對象的方法；

5，生成動態代理。

反射的API

學習一門語言，一種比較好的方式就是看它的API文檔，因為它的API是最權威的，最准確的。下面我們一起看看JDK的API對於反射是如何描述的吧！

與反射有關的所有接口以及類都在java.lang.reflect包里。

接口

接口摘要
AnnotatedElement	表示目前正在此 VM 中運行的程序的一個已注釋元素。
GenericArrayType	GenericArrayType 表示一種數組類型，其組件類型為參數化類型或類型變量。
GenericDeclaration	聲明類型變量的所有實體的公共接口。
InvocationHandler	InvocationHandler 是代理實例的調用處理程序 實現的接口。
Member	成員是一種接口，反映有關單個成員（字段或方法）或構造方法的標識信息。
ParameterizedType	ParameterizedType 表示參數化類型，如 Collection<String>。
Type	Type 是 Java 編程語言中所有類型的公共高級接口。
TypeVariable<D extends GenericDeclaration>	TypeVariable 是各種類型變量的公共高級接口。
WildcardType	WildcardType 表示一個通配符類型表達式，如 ?、? extends Number 或 ? super Integer。

類

類摘要
AccessibleObject	AccessibleObject 類是 Field、Method 和 Constructor 對象的基類。
Array	Array 類提供了動態創建和訪問 Java 數組的方法。
Constructor<T>	Constructor 提供關於類的單個構造方法的信息以及對它的訪問權限。
Field	Field 提供有關類或接口的單個字段的信息，以及對它的動態訪問權限。
Method	Method 提供關於類或接口上單獨某個方法（以及如何訪問該方法）的信息。
Modifier	Modifier 類提供了 static 方法和常量，對類和成員訪問修飾符進行解碼。
Proxy	Proxy 提供用於創建動態代理類和實例的靜態方法，它還是由這些方法創建的所有動態代理類的超類。
ReflectPermission	反射操作的 Permission 類。

下面給大家寫了一個小實例：

 package reflection;

 public class UserInfo {

     private Integer id;
     private String userName;
     private String password;
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getUserName() {
         return userName;
     }
     public void setUserName(String userName) {
         this.userName = userName;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }

     @Override
     public String toString(){
         return this.getClass().getName();
     }

 }

 package reflection;

 public class GetClass {

     public boolean ClassCheck(){
         try {

             System.out.println("第一種，通過類本身獲得對象");
             Class UserClass = this.getClass();
             System.out.println("第一種方式成功！類名："+UserClass.toString()+"\n");

             System.out.println("第二種，通過子類實例獲取父類");
             UserInfo ui = new UserInfo();
             UserClass = ui.getClass();
             Class SubUserClass = UserClass.getSuperclass();
             System.out.println("第二種方式成功！類名："+SubUserClass.toString()+"\n");

             System.out.println("第三種，通過類名加.class獲得對象");
             Class ForClass = reflection.UserInfo.class;
             System.out.println("第三種方式成功！類名："+ForClass.toString()+"\n");

             System.out.println("第四種，通過類名的字符串獲得對象");
             Class ForName = Class.forName("reflection.UserInfo");
             System.out.println("第四種方式成功！類名："+ForName.toString()+"\n");

         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
         return true;
     }

     @Override
     public String toString(){
         return this.getClass().getName();
     }

     public static void main(String[] args) {
         GetClass gc = new GetClass();
         gc.ClassCheck();
         if (gc.ClassCheck()) {
             System.out.println("所有反射全部成功！");
         }
         else {
             System.out.println("反射有問題，請檢查！");
         }
     }

 }

上面四種方法里面，我用的最多的是第四種，這種一般都是配合配置文件一起用的。反射與配置文件的結合讓我們的代碼變得非常的靈活，易擴展、以維護。可謂是好處多多呀，所以才有那句”反射反射，程序員的快樂！“一起盡情的快樂吧！

實例一：獲得完整的類名

 package reflection.getclassname;

 //獲得完整的類名
 public class GetClassName {

     public String getNameByClass() {

         String name = "";
         System.out.println("通過類本身獲得對象");
         Class UserClass = this.getClass();
         System.out.println("獲得對象成功！\n");

         System.out.println("通過類對象獲得類名");
         name = UserClass.getName();
         System.out.println("獲得類名成功！");
         return name;
     }
     public static void main(String[] args) {

         GetClassName gcn = new GetClassName();
         System.out.println("類名為："+gcn.getNameByClass());
     }

 }

運行結果：

通過類本身獲得對象
獲得對象成功！

通過類對象獲得類名
獲得類名成功！
類名為：reflection.getclassname.GetClass Name       

實例二：獲得類的屬性

 package reflection.getfields;

 import java.lang.reflect.Field;

 //獲得類的屬性
 public class GetFields {

     public static void getFieldNames(String className) {

         try {
             //獲得類名
             Class c = Class.forName(className);
             //獲得所有屬性
             Field[] fds = c.getFields();

             for (int i=0; i<fds.length; i++)
             {
                 String fn = fds[i].getName();
                 Class tc = fds[i].getType();
                 String ft = tc.getName();
                 System.out.println("該屬性的名字為："+fn+"，該屬性的類型為："+ft);
             }
         }catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         GetFields.getFieldNames("reflection.getfields.FieldInfo");
     }

 }

運行結果：

該屬性的名字為：id，該屬性的類型為：java.lang.String

該屬性的名字為：username，該屬性的類型為：java.lang.String    

實例三：獲得類實現的接口

 package reflection.getinterfaces;

 //獲得類實現的接口
 public class GetInterfaces {

     public static void getInterfaces(String className) {
         try {
             //取得類
             Class cl = Class.forName(className);
             Class[] ifs = cl.getInterfaces();
             for (int i = 0; i<ifs.length;i++)
             {
                 String IName = ifs[i].getName();
                 System.out.println("該類實現的接口名字為："+IName);
             }
         }catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         GetInterfaces.getInterfaces("reflection.getinterfaces.Student");
     }

 }

運行結果：

該類實現的接口名字為：reflection.getinterfaces.Person    

實例四：獲得類及其屬性的修飾符

 package reflection.getmodifiers;

 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;

 import reflection.UserInfo;

 //獲得類及其屬性的修飾符
 public class GetModifiers {

     private String username = "liu shui jing";
     float f = Float.parseFloat("1.000");
     public static final int i = 37;

     //獲得類的修飾符
     public static String useModifiers(UserInfo ui) {

         Class uiClass = ui.getClass();
         int m = uiClass.getModifiers();
         return Modifier.toString(m);

     }

     //獲得本類屬性的修飾符
     public void checkThisClassModifiers() {

         Class tc = this.getClass();
         Field fl[] = tc.getDeclaredFields();

         for(int i=0;i<fl.length;i++)
         {
             System.out.println("第"+(i+1)+"個屬性的修飾符為："+Modifier.toString(fl[i].getModifiers()));
         }

     }
     public static void main(String[] args) {

         //獲得類的修飾符
         UserInfo ui =new UserInfo();
         System.out.println("獲得這個類的修飾符："+GetModifiers.useModifiers(ui)+"\n");

         //獲得本類屬性的修飾符
         GetModifiers gm = new GetModifiers();
         gm.checkThisClassModifiers();

     }

 }

運行結果：

獲得這個類的修飾符：public

 

第1個屬性的修飾符為：private

第2個屬性的修飾符為：

第3個屬性的修飾符為：public static final      

實例五：獲得類的構造函數

 package reflection.getconstructor;

 import java.lang.reflect.Constructor;

 //獲得類的構造函數
 public class GetConstructor {

     //構造函數一
     GetConstructor(int a) {

     }

     //構造函數二
     GetConstructor(int a, String b) {

     }

     public static void getConstructorInfo(String className) {
         try {
             //獲得類的對象
             Class cl =Class.forName(className);
             System.out.println("獲得類"+className+"所有的構造函數");
             Constructor ctorlist[] = cl.getDeclaredConstructors();
             System.out.println("遍歷構造函數\n");
             for(int i =0 ; i<ctorlist.length; i++)
             {
                 Constructor con = ctorlist[i];
                 System.out.println("這個構造函數的名字為："+con.getName());
                 System.out.println("通過構造函數獲得這個類的名字為："+con.getDeclaringClass());

                 Class cp[] = con.getParameterTypes();
                 for (int j=0; j<cp.length; j++)
                 {
                     System.out.println("參數 "+j+" 為 "+cp[j]+"\n");
                 }
             }
         }catch (Exception e) {
                 System.err.println(e);
         }
     }
     public static void main(String[] args) {
         GetConstructor.getConstructorInfo("reflection.getconstructor.GetConstructor");
     }

 }

運行結果：

獲得類reflection.getconstructor.GetConstructor所有的構造函數

遍歷構造函數

 

這個構造函數的名字為：reflection.getconstructor.GetConstructor

通過構造函數獲得這個類的名字為：class reflection.getconstructor.GetConstructor       

參數 0 為 int

 

這個構造函數的名字為：reflection.getconstructor.GetConstructor

通過構造函數獲得這個類的名字為：class reflection.getconstructor.GetConstructor

參數 0 為 int

 

參數 1 為 class java.lang.String

實例六：獲得父類

 package reflection.getparentclass;

 //獲得父類
 public class GetParentClass {

     public static String getParentClass(UserInfoMore uim) {

         //獲得父類
         Class uimc = uim.getClass().getSuperclass();
         System.out.println("獲得父類的名字為："+uimc.getName());
         return uimc.getName();

     }

     public static void searchParentClass() {

     }

     public static void main(String[] args) {

         UserInfoMore uim = new UserInfoMore();
         System.out.println("成功獲得UserInfoMore的父類："+GetParentClass.getParentClass(uim));

     }

 }

運行結果：

獲得父類的名字為：reflection.UserInfo

成功獲得UserInfoMore的父類：reflection.UserInfo   

實例七：獲得類的方法

 package reflection.getmethod;

 import java.lang.reflect.Method;

 //獲得類的方法
 public class GetMethod {

     public static void getMethods(String className) {
         try {
             System.out.println("開始遍歷類"+className+".class");
             //獲得類名
             Class cls = Class.forName(className);
             //利用方法獲得所有該類的方法
             System.out.println("利用類的getDeclaredMethods獲得類的所有方法");
             Method ml[] =cls.getDeclaredMethods();
             System.out.println("遍歷獲得的方法數組\n");
             for (int i = 0 ;i<ml.length;i++)
             {
                 System.out.println("開始遍歷第"+(i+1)+"個方法");
                 Method m = ml[i];
                 System.out.println("開始獲取方法的變量類型");
                 Class ptype[] = m.getParameterTypes();
                 for (int j=0; j<ptype.length; j++)
                 {
                     System.out.println("方法參數"+j+"類型為"+ptype[j]);
                 }
                 Class gEx[] = m.getExceptionTypes();
                 for (int j=0 ; j<gEx.length; j++)
                 {
                     System.out.println("異常"+j+"為"+ gEx[j]);
                 }

                 System.out.println("該方法的返回值類型為："+m.getReturnType()+"\n");

             }
         }catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         GetMethod.getMethods("reflection.UserInfo");
     }

 }

運行結果：

開始遍歷類reflection.UserInfo.class

利用類的getDeclaredMethods獲得類的所有方法         

遍歷獲得的方法數組

 

開始遍歷第1個方法

開始獲取方法的變量類型

該方法的返回值類型為：class java.lang.String

 

開始遍歷第2個方法

開始獲取方法的變量類型

該方法的返回值類型為：class java.lang.Integer

 

開始遍歷第3個方法

開始獲取方法的變量類型

方法參數0類型為class java.lang.String

該方法的返回值類型為：void

 

開始遍歷第4個方法

開始獲取方法的變量類型

該方法的返回值類型為：class java.lang.String

 

開始遍歷第5個方法

開始獲取方法的變量類型

方法參數0類型為class java.lang.Integer

該方法的返回值類型為：void

 

開始遍歷第6個方法

開始獲取方法的變量類型

該方法的返回值類型為：class java.lang.String

 

開始遍歷第7個方法

開始獲取方法的變量類型

方法參數0類型為class java.lang.String

該方法的返回值類型為：void

 

這次實例不少吧，而且這些小例子都比較簡單，相信大家都可以輕松秒懂。上面一些例子的代碼並不是完整的，有些只有一些關鍵代碼，如果想要完整的代碼請戳下面的鏈接。最后祝大家學習愉快！

轉自http://blog.csdn.net/liushuijinger/article/details/14223459

http://blog.csdn.net/liushuijinger/article/details/15378475