`

Java反射应用实例

    博客分类:
  • java
阅读更多

本文主要通过Java反射应用实例来讲解 利用反射方法创建对象(使用默认构造函数和自定义构造函数) ,访问对应对象的方法(包括带参数的和不带参数的),访问对应对象的域(Field) . 从 这里 可以下载到完整的java代码工程:   http://download.csdn.net/detail/hejiangtao/4011663

很多IOC等框架都使用反射来实现,例如Spring, Hibernate等, Java反射的方式实现的逻辑比普通类逻辑的效率是要差一些的(14至300倍左右), 具体可以参考我转载的一篇文章<java反射的性能问题 >http://blog.csdn.net/hejiangtao/article/details/7188835.

首先看下我们实例中被访问的类DataTypeBean.java:

这个Bean中定义了4种类型的Field,包含了int, String,String数组和List; 定义了默认构造函数和自定义的构造函数; 还有一个给List域赋值的带参数函数; 一个不带参数的toString函数.我们要实现的就是使用反射的方法来访问这些Fields 和Methods.

 

[html] view plain copy
  1. package com.ross.reflect.bean;  
  2. import java.util.*;  
  3. /**  
  4.  * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
  5.  * Date: 2012-1-4  
  6.  * Since: MyJavaExpert v1.0  
  7.  * Description: It will contains some typical fields whose data types  
  8.  *   are using frequently. it will be used in the reflect test  
  9.  */  
  10. public class DataTypeBean  
  11. {  
  12.     private int iInt;  
  13.     private String sStr;  
  14.     private String[] saStr;  
  15.     List< Integer >  oList;  
  16.   
  17.     // default constructor  
  18.     public DataTypeBean()  
  19.     {  
  20.     }  
  21.   
  22.     // constructor with parameters  
  23.     public DataTypeBean(int iInt, String sStr, String[] saStr,  
  24.             List< Integer >  oList)  
  25.     {  
  26.         this.iInt  = iInt;  
  27.         this.saStr  = saStr;  
  28.         this.sStr  = sStr;  
  29.         this.oList  = oList;  
  30.     }  
  31.   
  32.     // method with parameter, it will set value of the list field  
  33.     public void addDataToList(int iStart, int iEnd)  
  34.     {  
  35.         if (iStart <   iEnd )  
  36.         {  
  37.             oList  =  new  ArrayList < Integer > ();  
  38.             while (iStart < = iEnd)  
  39.             {  
  40.                 oList.add(iStart);  
  41.                 iStart++;  
  42.             }  
  43.         }  
  44.     }  
  45.   
  46.     // method without parameter  
  47.     public String toString()  
  48.     {  
  49.         StringBuffer sbStr  =  new  StringBuffer();  
  50.         sbStr.append("Values of the fields of DataTypeBean: iInt  = ");  
  51.         sbStr.append(this.iInt).append(" ; ");  
  52.         for (int i  =  0 ; i  <   this.saStr.length ; i++)  
  53.         {  
  54.             sbStr.append("saStr").append("[").append(i).append("]").append(  
  55.                     " = ").append(saStr[i]).append(" ; ");  
  56.         }  
  57.   
  58.         for (int j  =  0 ; j  <   this.oList.size (); j++)  
  59.         {  
  60.             sbStr.append("oList.get").append("(").append(j).append(")").append(  
  61.                     " = ").append(oList.get(j)).append(" ; ");  
  62.         }  
  63.         return sbStr.toString();  
  64.     }  
  65.   
  66.     //省略了set/get方法  
  67. }  

来看我们的反射的实现类MyReflect.java, 由于担心代码太长不好看,就全部在Main函数里面写了,方便看.

1. 首先我们看下使用默认构造函数创建类对象, 并通过访问Field对象来给类对象赋值, 最后通过toString方法打印字符串.

初始化我们要使用的参数, 这些参数将用于给类的Field赋值:

[html] view plain copy
  1. int  iInt  =  2012 ;  
  2. String sStr  =  "This a string!" ;  
  3. String[] saStr  =  new  String[] { "First item of the string array",  
  4.         "Second item of the string array",  
  5.         "Third item of the string array" };  
  6. List< Integer >   oList  =  new  ArrayList < Integer > ();  
  7.   
  8. // Initialize the oList  
  9. int i  =  0 ;  
  10. while (i <   3 )  
  11. {  
  12.     oList.add(i);  
  13.     i++;  
  14. }  
获取 DataTypeBean的类,和我们将要用到的方法对象, 其中toString方法是不带参数的,addDataToList则是带参数的. 由此可以看出我们在使用反射方法的时候是需要知道参数个数和参数类型的:
[html] view plain copy
  1. // get class  
  2. Class oClass  = Class.forName("com.ross.reflect.bean.DataTypeBean");  
  3. // get the toString method, a method without parameters  
  4. Method oToStringMethod  =  oClass .getMethod("toString");  
  5. // get the addDataToList method, a method with parameters  
  6. Method oAddDataToListMethod  =  oClass .getMethod("addDataToList",  
  7.         int.class, int.class);  
使用默认构造函数创建一个 DataTypeBean的对象:
[html] view plain copy
  1. // used default constructor to initialize a object  
  2. Object oDefalutObject  =  oClass .newInstance();  
使用反射方法访问Field来给对象赋值:
[html] view plain copy
  1. // access fields process, getDeclaredFields can access private and  
  2. // protected fields  
  3. Field[] oFields  =  oClass .getDeclaredFields();  
  4. for (int j  =  0 ; j  <   oFields.length ; j++)  
  5. {  
  6.     // to access the private  
  7.     oFields[j].setAccessible(true);  
  8.   
  9.     // getSimpleName method can get the type of the field, according the  
  10.     // field type set the data to the field  
  11.     if ("int".equals(oFields[j].getType().getSimpleName()))  
  12.     {  
  13.         oFields[j].setInt(oDefalutObject, iInt);  
  14.     }  
  15.     else if ("String[]".equals(oFields[j].getType().getSimpleName()))  
  16.     {  
  17.         oFields[j].set(oDefalutObject, saStr);  
  18.     }  
  19.     else if ("String".equals(oFields[j].getType().getSimpleName()))  
  20.     {  
  21.         oFields[j].set(oDefalutObject, sStr);  
  22.     }  
  23.     else if ("List".equals(oFields[j].getType().getSimpleName()))  
  24.     {  
  25.         oFields[j].set(oDefalutObject, oList);  
  26.     }  
  27. }  
通过反射方法调用 DataTypeBean的toString方法将赋值后的 DataTypeBean打印出来:
[html] view plain copy
  1. // print the object  
  2. String sBeanString  = (String) oToStringMethod.invoke(oDefalutObject);  
  3. System.out  
  4.         .println("the string of the object created by defaut constructor: "  
  5.                 + sBeanString);  
运行后,我们的控制台打印出如下信息:
[html] view plain copy
  1. the string of the object created by defaut constructor: Values of the fields of DataTypeBean:  iInt  =  2012  ;   
  2. saStr[0] = First item of the string array ; saStr[1] = Second item of the string array ; saStr[2] = Third item   
  3. of the string array ; oList.get(0) = 0 ; oList.get(1) = 1 ; oList.get(2) = 2 ;   

2. 我们再看下使用自定义构造函数创建类对象, 并通过带参数的函数给其List域赋值, 最后通过toString方法打印字符串.

变更下我们要用的参数, 好在控制台上跟默认构造函数创建的对象的打印信息做区分:

[html] view plain copy
  1. // initialize the parameters for customized constructor, the oList will  
  2. // be initialized by the method with parameters  
  3. iInt  =  2013 ;  
  4. sStr  =  "This another string!" ;  
  5. saStr  =  new  String[] { "1st item of the string array",  
  6.         "2nd item of the string array", "3rd item of the string array" };  
  7. oList  =  new  ArrayList < Integer > ();  
使用自定义构造函数创建类对象:
[html] view plain copy
  1. // used customized constructor to initialize a object: DataTypeBean(int  
  2. // iInt, String sStr, String[] saStr, List< Integer >  oList)  
  3. Constructor oCon  =  oClass .getConstructor(int.class, String.class,  
  4.         String[].class, List.class);  
  5. Object oCustomizedObject  =  oCon .newInstance(iInt, sStr, saStr, oList);  
使用带参数的函数给List 域赋值:
[html] view plain copy
  1. //Use the method with parameters initialize the List Object  
  2.  oAddDataToListMethod.invoke(oCustomizedObject,2013,2015);  
同样的,通过反射方法调用 DataTypeBean的toString方法将赋值后的 DataTypeBean打印出来:
[html] view plain copy
  1. // print the object  
  2.        sBeanString  = (String) oToStringMethod.invoke(oCustomizedObject);  
  3.        System.out  
  4.                .println("the string of the object created by customized constructor: "  
  5.                        + sBeanString);  
运行后,我们的控制台打印如下信息:
[html] view plain copy
  1. the string of the object created by customized constructor: Values of the fields of DataTypeBean:  iInt  =  2013  ;   
  2. saStr[0] = 1st item of the string array ; saStr[1] = 2nd item of the string array ; saStr[2] = 3rd item of the  
  3.  string array ; oList.get(0) = 2013 ; oList.get(1) = 2014 ; oList.get(2) = 2015 ; oList.get(3) = 2016 ;   

为了方便参考,我将完整的MyReflect.java贴出来了:

 

[html] view plain copy
  1. package com.ross.reflect;  
  2. import java.lang.reflect.Constructor;  
  3. import java.lang.reflect.Field;  
  4. import java.lang.reflect.InvocationTargetException;  
  5. import java.lang.reflect.Method;  
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8. /**  
  9.  * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
  10.  * Date: 2012-1-9  
  11.  * Since: MyJavaExpert v1.0  
  12.  * Description: reflect method implementation and test  
  13.  */  
  14. public class MyReflect  
  15. {  
  16.     /**  
  17.      * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
  18.      * Date: 2012-1-9   
  19.      * Description: Use reflect method to access the fields and methods of DataTypebean  
  20.      */  
  21.     public static void main(String[] args) throws ClassNotFoundException,  
  22.             SecurityException, NoSuchMethodException, InstantiationException,  
  23.             IllegalAccessException, IllegalArgumentException,  
  24.             InvocationTargetException  
  25.     {  
  26.         int iInt  =  2012 ;  
  27.         String sStr  =  "This a string!" ;  
  28.         String[] saStr  =  new  String[] { "First item of the string array",  
  29.                 "Second item of the string array",  
  30.                 "Third item of the string array" };  
  31.         List< Integer >   oList  =  new  ArrayList < Integer > ();  
  32.   
  33.         // Initialize the oList  
  34.         int i  =  0 ;  
  35.         while (i <   3 )  
  36.         {  
  37.             oList.add(i);  
  38.             i++;  
  39.         }  
  40.         // get class  
  41.         Class oClass  = Class.forName("com.ross.reflect.bean.DataTypeBean");  
  42.         // get the toString method, a method without parameters  
  43.         Method oToStringMethod  =  oClass .getMethod("toString");  
  44.         // get the addDataToList method, a method with parameters  
  45.         Method oAddDataToListMethod  =  oClass .getMethod("addDataToList",  
  46.                 int.class, int.class);  
  47.   
  48.         // used default constructor to initialize a object  
  49.         Object oDefalutObject  =  oClass .newInstance();  
  50.   
  51.         // access fields process, getDeclaredFields can access private and  
  52.         // protected fields  
  53.         Field[] oFields  =  oClass .getDeclaredFields();  
  54.         for (int j  =  0 ; j  <   oFields.length ; j++)  
  55.         {  
  56.             // to access the private  
  57.             oFields[j].setAccessible(true);  
  58.   
  59.             // getSimpleName method can get the type of the field, according the  
  60.             // field type set the data to the field  
  61.             if ("int".equals(oFields[j].getType().getSimpleName()))  
  62.             {  
  63.                 oFields[j].setInt(oDefalutObject, iInt);  
  64.             }  
  65.             else if ("String[]".equals(oFields[j].getType().getSimpleName()))  
  66.             {  
  67.                 oFields[j].set(oDefalutObject, saStr);  
  68.             }  
  69.             else if ("String".equals(oFields[j].getType().getSimpleName()))  
  70.             {  
  71.                 oFields[j].set(oDefalutObject, sStr);  
  72.             }  
  73.             else if ("List".equals(oFields[j].getType().getSimpleName()))  
  74.             {  
  75.                 oFields[j].set(oDefalutObject, oList);  
  76.             }  
  77.         }  
  78.   
  79.         // print the object  
  80.         String sBeanString  = (String) oToStringMethod.invoke(oDefalutObject);  
  81.         System.out  
  82.                 .println("the string of the object created by defaut constructor: "  
  83.                         + sBeanString);  
  84.   
  85.         // initialize the parameters for customized constructor, the oList will  
  86.         // be initialized by the method with parameters  
  87.         iInt  =  2013 ;  
  88.         sStr  =  "This another string!" ;  
  89.         saStr  =  new  String[] { "1st item of the string array",  
  90.                 "2nd item of the string array", "3rd item of the string array" };  
  91.         oList  =  new  ArrayList < Integer > ();  
  92.   
  93.         // used customized constructor to initialize a object: DataTypeBean(int  
  94.         // iInt, String sStr, String[] saStr, List< Integer >  oList)  
  95.         Constructor oCon  =  oClass .getConstructor(int.class, String.class,  
  96.                 String[].class, List.class);  
  97.         Object oCustomizedObject  =  oCon .newInstance(iInt, sStr, saStr, oList);  
  98.         //Use the method with parameters initialize the List Object  
  99.         oAddDataToListMethod.invoke(oCustomizedObject,2013,2015);  
  100.           
  101.         // print the object  
  102.         sBeanString  = (String) oToStringMethod.invoke(oCustomizedObject);  
  103.         System.out  
  104.                 .println("the string of the object created by customized constructor: "  
  105.                         + sBeanString);  
  106.     }  
  107. }  
注: 转载请注明出处: http://hejiangtao.iteye.com用于商业得给我分成大笑
1
0
分享到:
评论
1 楼 yhx1231 2014-11-10  

相关推荐

    java反射应用实例

    在标题“Java反射应用实例”中,我们关注的是如何在实际项目中利用反射来实现特定的功能。这篇博客文章(可以通过链接访问)可能会探讨以下几个方面: 1. **什么是反射**:首先,我们需要理解反射的基本概念。反射...

    Java反射经典实例

    本实例将深入探讨Java反射的应用及其重要性。 一、什么是Java反射 Java反射机制允许我们动态地获取类的信息,并在运行时创建和调用对象的方法。这种能力使得Java具有高度的灵活性和动态性,特别是在处理跨版本兼容...

    java反射经典实例

    通过上述实例,我们可以看到Java反射机制在许多实际场景中的应用,它扩展了Java代码的灵活性和可扩展性。然而,也应注意,过度使用反射可能会引入复杂性和潜在的安全风险,因此在设计和实现时需权衡利弊。在理解了...

    Java反射机制经典案例

    Java反射机制是Java编程语言中的一个强大...通过以上介绍,我们了解了Java反射机制的基本概念、使用方法、应用场景以及需要注意的问题。在实际编程中,合理利用反射可以提高代码的灵活性,但同时也需注意其潜在的风险。

    java反射实例代码

    在提供的"java反射实例代码"中,应该包含了如何使用上述方法的实际示例,这些示例有助于加深对Java反射机制的理解。通过阅读和运行这些代码,开发者可以更直观地学习如何在程序运行时动态地操作类、方法和字段,从而...

    反射实例-JAVA反射机制

    ### 反射实例—JAVA反射机制 #### 一、反射概念及原理 反射在计算机科学领域,特别是程序设计中,是指程序有能力访问、检测和修改其自身的结构和行为。这一概念最早由Smith于1982年提出,并迅速应用于各种编程语言...

    java反射调用实例代码

    这个资源“java反射调用实例代码”提供了关于如何使用Java反射API进行各种操作的实际示例。 在Java中,`java.lang.reflect`包提供了对反射的支持,包括`Class`类,`Constructor`类,`Method`类和`Field`类。这些类...

    JAVA反射机制的入门代码

    Java反射机制是Java编程语言中的一个强大特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这个特性使得Java具有了高度的灵活性和动态性,尤其是在处理元数据、创建对象、调用私有方法...

    java反射 java反射 java反射java反射

    Java反射是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中,反射机制提供了强大的能力,包括在运行时检查类的结构、创建对象实例、调用方法以及访问和修改字段值。...

    java反射机制应用

    ### Java反射机制应用详解 #### 一、Java反射机制简介 Java反射机制是Java语言提供的一种能在运行时分析类信息并动态操作对象的功能。通过反射,我们可以在程序运行期间获取类的信息(如类名、方法名等),创建...

    Java反射案例

    这个案例将深入探讨如何使用Java反射来实现一些实用的功能。 1. **获取类信息**: 反射机制首先从Class对象开始,它是所有Java类的元数据。通过`Class.forName()`方法或`类名.class`可以获取到Class对象。一旦有了...

    Java 反射机制 代码的实例

    Java反射机制是Java编程语言中的一个强大特性,它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射,开发者可以动态地获取类的信息并调用其方法,创建对象,访问私有成员,甚至改变类的行为。在深入...

    Java反射性能测试分析

    ### Java反射性能测试分析 ...- [Java Reflection and Performance: A Deep Dive](https://www.baeldung.com/java-reflection-performance):一篇深入分析Java反射性能的文章,包含更多的测试案例和优化建议。

    java 反射实例,大量注释,简单易懂

    Java反射是Java编程语言中的一个重要特性,它允许程序在...学习这个示例,你可以更好地掌握Java反射机制,如何实例化对象,调用方法以及访问字段。通过实践,你将能够灵活地应用反射到实际项目中,解决动态编程的需求。

    JAVA 反射机制应用

    Java反射机制是Java语言提供的一种强大功能,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中,反射机制的核心类是java.lang.Class,它代表了运行时的类信息。通过Class对象,我们...

    java 反射的使用

    以下是对Java反射使用及相关知识点的详细阐述: 1. **获取Class对象** - `Class.forName(String className)`: 通过全限定类名获取Class对象。 - `object.getClass()`: 对象的`getClass()`方法返回该对象的Class...

    Java反射动态加载实例类

    本文将深入探讨Java反射机制,并通过一个具体的示例来演示如何使用反射动态加载实例类。 #### 一、Java反射概述 Java反射API主要由以下类和接口组成: - `java.lang.Class`:表示一个类或接口的信息。 - `java....

    Java反射简单小实例

    ### Java反射机制的使用场景 反射通常用于以下几种情况: - 动态创建对象。 - 获取并操作对象属性和方法。 - 实现框架和库的功能扩展。 - 进行单元测试时模拟某些行为。 ### 示例代码解析 在给定的示例代码中,...

Global site tag (gtag.js) - Google Analytics