Java实例讲解反射机制Reflection

1. 得到某个对象的属性

目前累计服务客户数千家，积累了丰富的产品开发及服务经验。以网站设计水平和技术实力，树立企业形象，为客户提供成都网站设计、网站建设、外贸网站建设、网站策划、网页设计、网络营销、VI设计、网站改版、漏洞修补等服务。创新互联公司始终以务实、诚信为根本，不断创新和提高建站品质，通过对领先技术的掌握、对创意设计的研究、对客户形象的视觉传递、对应用系统的结合，为客户提供更好的一站式互联网解决方案，携手广大客户，共同发展进步。

Java实例

 
 
 
    
  
  
  
  1. public Object getProperty(Object owner, String fieldName) throws Exception {         
    2. 
  
  
  
  2.     Class ownerownerClass = owner.getClass();                                             
    3. 
  
  
  
  3.                                                                                      
    4. 
  
  
  
  4.     Field field = ownerClass.getField(fieldName);                                    
    5. 
  
  
  
  5.                                                                                      
    6. 
  
  
  
  6.     Object property = field.get(owner);                                              
    7. 
  
  
  
  7.                                                                                      
    8. 
  
  
  
  8.     return property;                                                                 
    9. 
  
  
  
  9. }  
    10.

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性

 
 
 
    
  
  
  
  1. public Object getStaticProperty(String className, String fieldName)       
    2. 
  
  
  
  2.             throws Exception {                                            
    3. 
  
  
  
  3.     Class ownerClass = Class.forName(className);                          
    4. 
  
  
  
  4.                                                                           
    5. 
  
  
  
  5.     Field field = ownerClass.getField(fieldName);                         
    6. 
  
  
  
  6.                                                                           
    7. 
  
  
  
  7.     Object property = field.get(ownerClass);                              
    8. 
  
  
  
  8.                                                                           
    9. 
  
  
  
  9.     return property;                                                      
    10. 
  
  
  
  10. }     
    11.

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

 
 
 
    
  
  
  
  1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {      
    2. 
  
  
  
  2.     Class ownerownerClass = owner.getClass();      
    3. 
  
  
  
  3.     Class[] argsClass = new Class[args.length];      
    4. 
  
  
  
  4.     for (int i = 0, j = args.length; i < j; i++) {      
    5. 
  
  
  
  5.         argsClass[i] = args[i].getClass();      
    6. 
  
  
  
  6.     }       
    7. 
  
  
  
  7.     Method method = ownerClass.getMethod(methodName, argsClass);         
    8. 
  
  
  
  8.     return method.invoke(owner, args);       
    9. 
  
  
  
  9. } 
    10.

  
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

3～6行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法

 
 
 
    
  
  
  
  1. public Object invokeStaticMethod(String className, String methodName,               
    2. 
  
  
  
  2.             Object[] args) throws Exception {                                       
    3. 
  
  
  
  3.     Class ownerClass = Class.forName(className);                                    
    4. 
  
  
  
  4.                                                                                     
    5. 
  
  
  
  5.     Class[] argsClass = new Class[args.length];                                     
    6. 
  
  
  
  6.                                                                                     
    7. 
  
  
  
  7.     for (int i = 0, j = args.length; i < j; i++) {                                  
    8. 
  
  
  
  8.         argsClass[i] = args[i].getClass();                                          
    9. 
  
  
  
  9.     }                                                                               
    10. 
  
  
  
  10.                                                                                     
    11. 
  
  
  
  11.     Method method = ownerClass.getMethod(methodName, argsClass);                    
    12. 
  
  
  
  12.                                                                                     
    13. 
  
  
  
  13.     return method.invoke(null, args);                                               
    14. 
  
  
  
  14. }   
    15.

基本的原理和实例3相同，不同点是***一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建Java实例

 
 
 
    
  
  
  
  1. public Object newInstance(String className, Object[] args) throws Exception {       
    2. 
  
  
  
  2.     Class newoneClass = Class.forName(className);                                   
    3. 
  
  
  
  3.                                                                                     
    4. 
  
  
  
  4.     Class[] argsClass = new Class[args.length];                                     
    5. 
  
  
  
  5.                                                                                     
    6. 
  
  
  
  6.     for (int i = 0, j = args.length; i < j; i++) {                                  
    7. 
  
  
  
  7.         argsClass[i] = args[i].getClass();                                          
    8. 
  
  
  
  8.     }                                                                               
    9. 
  
  
  
  9.                                                                                     
    10. 
  
  
  
  10.     Constructor cons = newoneClass.getConstructor(argsClass);                       
    11. 
  
  
  
  11.                                                                                     
    12. 
  
  
  
  12.     return cons.newInstance(args);                                                  
    13. 
  
  
  
  13.                                                                                     
    14. 
  
  
  
  14. }   
    15.

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：***步，得到要构造的实例的Class。

第6～第10行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的Java实例

 
 
 
    
  
  
  
  1. public boolean isInstance(Object obj, Class cls) {           
    2. 
  
  
  
  2.     return cls.isInstance(obj);                              
    3. 
  
  
  
  3. }     
    4.

7. 得到数组中的某个元素

 
 
 
    
  
  
  
  1. public Object getByArray(Object array, int index) {          
    2. 
  
  
  
  2.     return Array.get(array,index);                           
    3. 
  
  
  
  3. }       
    4.

附完整源码：

 
 
 
    
  
  
  
  1. import java.lang.reflect.Array;      
    2. 
  
  
  
  2. import java.lang.reflect.Constructor;      
    3. 
  
  
  
  3. import java.lang.reflect.Field;      
    4. 
  
  
  
  4. import java.lang.reflect.Method;      
    5. 
  
  
  
  5.      
    6. 
  
  
  
  6.      
    7. 
  
  
  
  7. /**     
    8. 
  
  
  
  8.  * Java Reflection Cookbook     
    9. 
  
  
  
  9.  *     
    10. 
  
  
  
  10.  * @author Michael Lee     
    11. 
  
  
  
  11.  * @since 2006-8-23     
    12. 
  
  
  
  12.  * @version 0.1a     
    13. 
  
  
  
  13.  */     
    14. 
  
  
  
  14.      
    15. 
  
  
  
  15. public class Reflection {      
    16. 
  
  
  
  16.     /**     
    17. 
  
  
  
  17.      * 得到某个对象的公共属性     
    18. 
  
  
  
  18.      *     
    19. 
  
  
  
  19.      * @param owner, fieldName     
    20. 
  
  
  
  20.      * @return 该属性对象     
    21. 
  
  
  
  21.      * @throws Exception     
    22. 
  
  
  
  22.      *     
    23. 
  
  
  
  23.      */     
    24. 
  
  
  
  24.     public Object getProperty(Object owner, String fieldName) throws Exception {      
    25. 
  
  
  
  25.         Class ownerownerClass = owner.getClass();      
    26. 
  
  
  
  26.      
    27. 
  
  
  
  27.         Field field = ownerClass.getField(fieldName);      
    28. 
  
  
  
  28.      
    29. 
  
  
  
  29.         Object property = field.get(owner);      
    30. 
  
  
  
  30.      
    31. 
  
  
  
  31.         return property;      
    32. 
  
  
  
  32.     }      
    33. 
  
  
  
  33.      
    34. 
  
  
  
  34.     /**     
    35. 
  
  
  
  35.      * 得到某类的静态公共属性     
    36. 
  
  
  
  36.      *     
    37. 
  
  
  
  37.      * @param className   类名     
    38. 
  
  
  
  38.      * @param fieldName   属性名     
    39. 
  
  
  
  39.      * @return 该属性对象     
    40. 
  
  
  
  40.      * @throws Exception     
    41. 
  
  
  
  41.      */     
    42. 
  
  
  
  42.     public Object getStaticProperty(String className, String fieldName)      
    43. 
  
  
  
  43.             throws Exception {      
    44. 
  
  
  
  44.         Class ownerClass = Class.forName(className);      
    45. 
  
  
  
  45.      
    46. 
  
  
  
  46.         Field field = ownerClass.getField(fieldName);      
    47. 
  
  
  
  47.      
    48. 
  
  
  
  48.         Object property = field.get(ownerClass);      
    49. 
  
  
  
  49.      
    50. 
  
  
  
  50.         return property;      
    51. 
  
  
  
  51.     }      
    52. 
  
  
  
  52.      
    53. 
  
  
  
  53.      
    54. 
  
  
  
  54.     /**     
    55. 
  
  
  
  55.      * 执行某对象方法     
    56. 
  
  
  
  56.      *     
    57. 
  
  
  
  57.      * @param owner     
    58. 
  
  
  
  58.      *            对象     
    59. 
  
  
  
  59.      * @param methodName     
    60. 
  
  
  
  60.      *            方法名     
    61. 
  
  
  
  61.      * @param args     
    62. 
  
  
  
  62.      *            参数     
    63. 
  
  
  
  63.      * @return 方法返回值     
    64. 
  
  
  
  64.      * @throws Exception     
    65. 
  
  
  
  65.      */     
    66. 
  
  
  
  66.     public Object invokeMethod(Object owner, String methodName, Object[] args)      
    67. 
  
  
  
  67.             throws Exception {      
    68. 
  
  
  
  68.      
    69. 
  
  
  
  69.         Class ownerownerClass = owner.getClass();      
    70. 
  
  
  
  70.      
    71. 
  
  
  
  71.         Class[] argsClass = new Class[args.length];      
    72. 
  
  
  
  72.      
    73. 
  
  
  
  73.         for (int i = 0, j = args.length; i < j; i++) {      
    74. 
  
  
  
  74.             argsClass[i] = args[i].getClass();      
    75. 
  
  
  
  75.         }      
    76. 
  
  
  
  76.      
    77. 
  
  
  
  77.         Method method = ownerClass.getMethod(methodName, argsClass);      
    78. 
  
  
  
  78.      
    79. 
  
  
  
  79.         return method.invoke(owner, args);      
    80. 
  
  
  
  80.     }      
    81. 
  
  
  
  81.      
    82. 
  
  
  
  82.      
    83. 
  
  
  
  83.       /**     
    84. 
  
  
  
  84.      * 执行某类的静态方法     
    85. 
  
  
  
  85.      *     
    86. 
  
  
  
  86.      * @param className     
    87. 
  
  
  
  87.      *            类名     
    88. 
  
  
  
  88.      * @param methodName     
    89. 
  
  
  
  89.      *            方法名     
    90. 
  
  
  
  90.      * @param args     
    91. 
  
  
  
  91.      *            参数数组     
    92. 
  
  
  
  92.      * @return 执行方法返回的结果     
    93. 
  
  
  
  93.      * @throws Exception     
    94. 
  
  
  
  94.      */     
    95. 
  
  
  
  95.     public Object invokeStaticMethod(String className, String methodName,      
    96. 
  
  
  
  96.             Object[] args) throws Exception {      
    97. 
  
  
  
  97.         Class ownerClass = Class.forName(className);      
    98. 
  
  
  
  98.      
    99. 
  
  
  
  99.         Class[] argsClass = new Class[args.length];      
    100. 
  
  
  
  100.      
    101. 
  
  
  
  101.         for (int i = 0, j = args.length; i < j; i++) {      
    102. 
  
  
  
  102.             argsClass[i] = args[i].getClass();      
    103. 
  
  
  
  103.         }      
    104. 
  
  
  
  104.      
    105. 
  
  
  
  105.         Method method = ownerClass.getMethod(methodName, argsClass);      
    106. 
  
  
  
  106.      
    107. 
  
  
  
  107.         return method.invoke(null, args);      
    108. 
  
  
  
  108.     }      
    109. 
  
  
  
  109.      
    110. 
  
  
  
  110.      
    111. 
  
  
  
  111.      
    112. 
  
  
  
  112.     /**     
    113. 
  
  
  
  113.      * 新建实例     
    114. 
  
  
  
  114.      *     
    115. 
  
  
  
  115.      * @param className     
    116. 
  
  
  
  116.      *            类名     
    117. 
  
  
  
  117.      * @param args     
    118. 
  
  
  
  118.      *            构造函数的参数     
    119. 
  
  
  
  119.      * @return 新建的实例     
    120. 
  
  
  
  120.      * @throws Exception     
    121. 
  
  
  
  121.      */     
    122. 
  
  
  
  122.     public Object newInstance(String className, Object[] args) throws Exception {      
    123. 
  
  
  
  123.         Class newoneClass = Class.forName(className);      
    124. 
  
  
  
  124.      
    125. 
  
  
  
  125.         Class[] argsClass = new Class[args.length];      
    126. 
  
  
  
  126.      
    127. 
  
  
  
  127.         for (int i = 0, j = args.length; i < j; i++) {      
    128. 
  
  
  
  128.             argsClass[i] = args[i].getClass();      
    129. 
  
  
  
  129.         }      
    130. 
  
  
  
  130.      
    131. 
  
  
  
  131.         Constructor cons = newoneClass.getConstructor(argsClass);      
    132. 
  
  
  
  132.      
    133. 
  
  
  
  133.         return cons.newInstance(args);      
    134. 
  
  
  
  134.      
    135. 
  
  
  
  135.     }      
    136. 
  
  
  
  136.      
    137. 
  
  
  
  137.      
    138. 
  
  
  
  138.           
    139. 
  
  
  
  139.     /**     
    140. 
  
  
  
  140.      * 是不是某个类的实例     
    141. 
  
  
  
  141.      * @param obj 实例     
    142. 
  
  
  
  142.      * @param cls 类     
    143. 
  
  
  
  143.      * @return 如果 obj 是此类的实例，则返回 true     
    144. 
  
  
  
  144.      */     
    145. 
  
  
  
  145.     public boolean isInstance(Object obj, Class cls) {      
    146. 
  
  
  
  146.         return cls.isInstance(obj);      
    147. 
  
  
  
  147.     }      
    148. 
  
  
  
  148.           
    149. 
  
  
  
  149.     /**     
    150. 
  
  
  
  150.      * 得到数组中的某个元素     
    151. 
  
  
  
  151.      * @param array 数组     
    152. 
  
  
  
  152.      * @param index 索引     
    153. 
  
  
  
  153.      * @return 返回指定数组对象中索引组件的值     
    154. 
  
  
  
  154.      */     
    155. 
  
  
  
  155.     public Object getByArray(Object array, int index) {      
    156. 
  
  
  
  156.         return Array.get(array,index);      
    157. 
  
  
  
  157.     }      
    158.

以上就是Java实例讲解反射机制Reflection的全部内容

网页题目：Java实例讲解反射机制Reflection
本文链接：http://www.mswzjz.cn/qtweb/news40/215090.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

外贸网站建设知识

同城分类信息

边坡防护网　　 　小程序开发　　 　微信小程序开发　　 　h5响应式网站　　 　香港虚拟主机　　 　网站免费收录　　 　成都网站设计公司　　 　橡塑保温材料　　 　德阳东方电机技改　　 　网站seo优化　　 　成都店面装修公司　　 　成都网站建设　　 　ssl数字证书　　 　成都模板网站　　 　成都h5建站开发　　 　网站改版　　 　成都微信小程序　　 　品牌网站建设　　 　响应式网站建设方案　　 　成都富士康招工