Java高级特性之反射学习总结

老规矩我们还是先提出几个问题，一门技术必然要能解决一定的问题，才有去学习掌握它的价值

东辽ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为成都创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：13518219792（备注：SSL证书合作）期待与您的合作！

  • 一、 什么是反射?
  • 二、反射能做什么?

一、 什么是反射?

用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得老牌称的class，获悉其完整构造(但不包括methods定义)，并生成其对象实体、或对其fields设值、或唤起其methods。

如果你是一个Android Developer，前辈们都会教导你尽量少用反射，效率太低，太慢。“射”嘛，射的太快就不好了，所以反射虽然慢点，但是偶尔射一下还是很”爽”的。

二、反射能做什么?

1、新建类的实例

我们知道所有的类都继承子***父类Object，而Object中有hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象。我们这里就需要使用的Class对象，注意C是大写，我们可以通过一下方式来获取Class对象

  1. Class.forName(“类名字符串”) (注意：类名字符串必须是全称，包名+类名)
  2. 类名.class
  3. 实例对象.getClass()

在Class类中有一个非常重要的方法

 
 
 
    
  
  
  
  1. public T newInstance() throws InstantiationException, IllegalAccessException {
    2. 
  
  
  
  2.        return newInstanceImpl();
    3. 
  
  
  
  3.    }
    4. 
  
  
  
  4. 
  
  
  
  5. private native T newInstanceImpl() throws IllegalAccessException, InstantiationException; 
    6.

查看Api可以看到调用newInstace方法可以返回当前class对应的实例对象。接下来看一个小的Demo

 
 
 
    
  
  
  
  1. public class Reflection {
    2. 
  
  
  
  2. 
  
  
  
  3.     public static void main(String[] args) {
    4. 
  
  
  
  4. 
  
  
  
  5.         // 普通创建类的实例
    6. 
  
  
  
  6. 
  
  
  
  7.         People p1 = new People();
    8. 
  
  
  
  8.         System.out.println(p1.getName());
    9. 
  
  
  
  9.         // 利用反射获取类的实例
    10. 
  
  
  
  10.         Class clazz = People.class;
    11. 
  
  
  
  11.         // 常用方式,注意括号中需要放类的全路径名
    12. 
  
  
  
  12.         // Class clazz = Class.forName("reflection.People");
    13. 
  
  
  
  13.         // Class clazz = p1.getClass();
    14. 
  
  
  
  14.         try {
    15. 
  
  
  
  15.             People p2 = (People) clazz.newInstance();
    16. 
  
  
  
  16.             System.out.println(p2.getName());
    17. 
  
  
  
  17.         } catch (Exception e) {
    18. 
  
  
  
  18.             e.printStackTrace();
    19. 
  
  
  
  19.         }
    20. 
  
  
  
  20. 
  
  
  
  21.     }
    22. 
  
  
  
  22. 
  
  
  
  23. }
    24. 
  
  
  
  24. 
  
  
  
  25. class People {
    26. 
  
  
  
  26. 
  
  
  
  27.     private String name = "张三";
    28. 
  
  
  
  28.     private int age;
    29. 
  
  
  
  29. 
  
  
  
  30.     public String getName() {
    31. 
  
  
  
  31.         return name;
    32. 
  
  
  
  32.     }
    33. 
  
  
  
  33. 
  
  
  
  34.     public void setName(String name) {
    35. 
  
  
  
  35.         this.name = name;
    36. 
  
  
  
  36.     }
    37. 
  
  
  
  37. 
  
  
  
  38.     public int getAge() {
    39. 
  
  
  
  39.         return age;
    40. 
  
  
  
  40.     }
    41. 
  
  
  
  41. 
  
  
  
  42.     public void setAge(int age) {
    43. 
  
  
  
  43.         this.age = age;
    44. 
  
  
  
  44.     }
    45. 
  
  
  
  45. 
  
  
  
  46. } 
    47.

输入结果：

 
 
 
    
  
  
  
  1. 张三
    2. 
  
  
  
  2.  张三 
    3.

2、获取成员变量和方法

在讲之前我们先来看这样一个小按理，JSON数据转JavaBaen对象，在不用解析库的情况下，一般我们会这样做

 
 
 
    
  
  
  
  1. private void analysisDate(JSONObject response) throws JSONException {
    2. 
  
  
  
  2.         int announceid = response.getInt("announceid");
    3. 
  
  
  
  3.         String title = response.getString("title");
    4. 
  
  
  
  4.         String hits = response.getString("hits");
    5. 
  
  
  
  5.         String addtime = response.getString("addtime");
    6. 
  
  
  
  6.         NewsNotifyItem newsNotifyItem = new NewsNotifyItem(announceid,
    7. 
  
  
  
  7.                 title, hits, addtime);
    8. 
  
  
  
  8.     }
    9. 
  
  
  
  9. } 
    10.

每当我们需要解析额时候，都需要根据不同javabean来进行相应的解析，我们每次进行的操作都是一样的，只是解析的数据不同而已，结合上篇帖子讲到的泛型，这里我们就可以再利用反射来自己做一个Json解析工具。

下面是我写的一个JsonObject对象转JavaBean的一个工具类，需要注意的是，JSON的key需要和字段名保持一致，先说下思路

①首先通过反射获取JavaBean中的所有字段值的名称

②拼接出set方法

③由于字段名和Json的key值相同，利用自动名获取Json中的值并填充的实例对象中

 
 
 
    
  
  
  
  1. public class Json2BeanUtils {
    2. 
  
  
  
  2. 
  
  
  
  3.     public static  T jsonToBean(JSONObject response, Class clazz) {
    4. 
  
  
  
  4.         try {
    5. 
  
  
  
  5.             // 创建类的实例
    6. 
  
  
  
  6.             Object object = Class.forName(clazz.getName()).newInstance();
    7. 
  
  
  
  7.             // 获取类中的所有成员变量
    8. 
  
  
  
  8.             Field[] fields = object.getClass().getDeclaredFields();
    9. 
  
  
  
  9.             for (int i = 0; i < fields.length; i++) {
    10. 
  
  
  
  10.                 //设置权限
    11. 
  
  
  
  11.                 fields[i].setAccessible(true);
    12. 
  
  
  
  12.                 // 获取字段的名称
    13. 
  
  
  
  13.                 String fieldName = fields[i].getName();
    14. 
  
  
  
  14.                 // 过滤掉UID
    15. 
  
  
  
  15.                 if (fieldName.endsWith("serialVersionUID")) {
    16. 
  
  
  
  16.                     continue;
    17. 
  
  
  
  17.                 }
    18. 
  
  
  
  18.                 // 获取字段的类型
    19. 
  
  
  
  19.                 String fieldType = fields[i].getGenericType().toString();
    20. 
  
  
  
  20.                 // 拼接出JavaBean中的set方法 这里有一个坑 后面讲解
    21. 
  
  
  
  21.                 String methodName = "set"
    22. 
  
  
  
  22.                         + fieldName.substring(0, 1).toUpperCase()
    23. 
  
  
  
  23.                         + fieldName.substring(1);
    24. 
  
  
  
  24.                 try {
    25. 
  
  
  
  25.                     // 判断变量类型
    26. 
  
  
  
  26.                     if (fieldType.endsWith("class java.lang.String")) {
    27. 
  
  
  
  27.                         // 获取到set方法
    28. 
  
  
  
  28.                         Method m = object.getClass().getMethod(methodName,
    29. 
  
  
  
  29.                                 String.class);
    30. 
  
  
  
  30.                         String value = null;
    31. 
  
  
  
  31.                         try {
    32. 
  
  
  
  32.                             // 从JsonObj中取出相应的值
    33. 
  
  
  
  33.                             value = response.getString(fieldName);
    34. 
  
  
  
  34.                         } catch (Exception e) {
    35. 
  
  
  
  35.                             e.printStackTrace();
    36. 
  
  
  
  36.                             value = "";
    37. 
  
  
  
  37.                         }
    38. 
  
  
  
  38.                         if (TextUtils.isEmpty(value)) {
    39. 
  
  
  
  39.                             value = "";
    40. 
  
  
  
  40.                         } else if (value.endsWith("null")) {
    41. 
  
  
  
  41.                             value = "";
    42. 
  
  
  
  42.                         }
    43. 
  
  
  
  43.                         // 赋值
    44. 
  
  
  
  44.                         m.invoke(object, value);
    45. 
  
  
  
  45.                     } else if (fieldType.endsWith("int")
    46. 
  
  
  
  46.                             || fieldType.endsWith("class java.lang.Integer")) {
    47. 
  
  
  
  47.                         // int 类型
    48. 
  
  
  
  48.                         System.out.println();
    49. 
  
  
  
  49.                         Method m = object.getClass().getMethod(methodName,
    50. 
  
  
  
  50.                                 int.class);
    51. 
  
  
  
  51.                         int value = -1;
    52. 
  
  
  
  52.                         try {
    53. 
  
  
  
  53.                             value = response.getInt(fieldName);
    54. 
  
  
  
  54.                         } catch (Exception e) {
    55. 
  
  
  
  55.                             e.printStackTrace();
    56. 
  
  
  
  56.                             value = -1;
    57. 
  
  
  
  57.                         }
    58. 
  
  
  
  58.                         m.invoke(object, value);
    59. 
  
  
  
  59. 
  
  
  
  60.                     } else if (fieldType.endsWith("boolean")
    61. 
  
  
  
  61.                             || fieldType
    62. 
  
  
  
  62.                                     .endsWith("fieldType:class java.lang.Boolean")) {
    63. 
  
  
  
  63.                         // boolean 类型
    64. 
  
  
  
  64.                         Method m = object.getClass().getMethod(methodName,
    65. 
  
  
  
  65.                                 boolean.class);
    66. 
  
  
  
  66.                         boolean value = false;
    67. 
  
  
  
  67.                         try {
    68. 
  
  
  
  68.                             value = response.getBoolean(fieldName);
    69. 
  
  
  
  69.                         } catch (Exception e) {
    70. 
  
  
  
  70.                             e.printStackTrace();
    71. 
  
  
  
  71.                             value = false;
    72. 
  
  
  
  72.                         }
    73. 
  
  
  
  73.                         m.invoke(object, value);
    74. 
  
  
  
  74.                     } else if (fieldType.endsWith("double")
    75. 
  
  
  
  75.                             || fieldType
    76. 
  
  
  
  76.                                     .endsWith("fieldType:class java.lang.Double")) {
    77. 
  
  
  
  77.                         // double 类型
    78. 
  
  
  
  78.                         Method m = object.getClass().getMethod(methodName,
    79. 
  
  
  
  79.                                 double.class);
    80. 
  
  
  
  80.                         double value = -1D;
    81. 
  
  
  
  81.                         try {
    82. 
  
  
  
  82.                             value = response.getDouble(fieldName);
    83. 
  
  
  
  83.                         } catch (Exception e) {
    84. 
  
  
  
  84.                             e.printStackTrace();
    85. 
  
  
  
  85.                             value = -1D;
    86. 
  
  
  
  86.                         }
    87. 
  
  
  
  87.                         m.invoke(object, value);
    88. 
  
  
  
  88.                     } else if (fieldType.endsWith("char")) {
    89. 
  
  
  
  89.                         // char类型 JSONObject 没有char
    90. 
  
  
  
  90.                         Method m = object.getClass().getMethod(methodName,
    91. 
  
  
  
  91.                                 String.class);
    92. 
  
  
  
  92.                         String value = "";
    93. 
  
  
  
  93.                         try {
    94. 
  
  
  
  94.                             value = response.getString(fieldName);
    95. 
  
  
  
  95.                         } catch (Exception e) {
    96. 
  
  
  
  96.                             e.printStackTrace();
    97. 
  
  
  
  97.                             value = "";
    98. 
  
  
  
  98.                         }
    99. 
  
  
  
  99.                         m.invoke(object, value);
    100. 
  
  
  
  100.                     } else if (fieldType.endsWith("float")
    101. 
  
  
  
  101.                             || fieldType
    102. 
  
  
  
  102.                                     .endsWith("fieldType:class java.lang.Float")) {
    103. 
  
  
  
  103.                         // float类型
    104. 
  
  
  
  104.                         Method m = object.getClass().getMethod(methodName,
    105. 
  
  
  
  105.                                 double.class);
    106. 
  
  
  
  106.                         double value = -1D;
    107. 
  
  
  
  107.                         try {
    108. 
  
  
  
  108.                             value = response.getDouble(fieldName);
    109. 
  
  
  
  109.                         } catch (Exception e) {
    110. 
  
  
  
  110.                             e.printStackTrace();
    111. 
  
  
  
  111.                             value = -1D;
    112. 
  
  
  
  112.                         }
    113. 
  
  
  
  113.                         m.invoke(object, value);
    114. 
  
  
  
  114. 
  
  
  
  115.                     } else if (fieldType.endsWith("short")
    116. 
  
  
  
  116.                             || fieldType
    117. 
  
  
  
  117.                                     .endsWith("fieldType:class java.lang.Short")) {
    118. 
  
  
  
  118.                         // short
    119. 
  
  
  
  119.                         Method m = object.getClass().getMethod(methodName,
    120. 
  
  
  
  120.                                 short.class);
    121. 
  
  
  
  121.                         int value = -1;
    122. 
  
  
  
  122.                         try {
    123. 
  
  
  
  123.                             value = response.getInt(fieldName);
    124. 
  
  
  
  124.                         } catch (Exception e) {
    125. 
  
  
  
  125.                             e.printStackTrace();
    126. 
  
  
  
  126.                             value = -1;
    127. 
  
  
  
  127.                         }
    128. 
  
  
  
  128.                         m.invoke(object, value);
    129. 
  
  
  
  129.                     } else if (fieldType.endsWith("byte")
    130. 
  
  
  
  130.                             || fieldType
    131. 
  
  
  
  131.                                     .endsWith("fieldType:class java.lang.Byte")) {
    132. 
  
  
  
  132.                         Method m = object.getClass().getMethod(methodName,
    133. 
  
  
  
  133.                                 byte.class);
    134. 
  
  
  
  134.                         int value = -1;
    135. 
  
  
  
  135.                         try {
    136. 
  
  
  
  136.                             value = response.getInt(fieldName);
    137. 
  
  
  
  137.                         } catch (Exception e) {
    138. 
  
  
  
  138.                             e.printStackTrace();
    139. 
  
  
  
  139.                             value = -1;
    140. 
  
  
  
  140.                         }
    141. 
  
  
  
  141.                         m.invoke(object, value);
    142. 
  
  
  
  142.                     } else if (fieldType.endsWith("long")
    143. 
  
  
  
  143.                             || fieldType
    144. 
  
  
  
  144.                                     .endsWith("fieldType:class java.lang.Long")) {
    145. 
  
  
  
  145.                         Method m = object.getClass().getMethod(methodName,
    146. 
  
  
  
  146.                                 long.class);
    147. 
  
  
  
  147.                         Long value = -1L;
    148. 
  
  
  
  148.                         try {
    149. 
  
  
  
  149.                             value = response.getLong(fieldName);
    150. 
  
  
  
  150.                         } catch (Exception e) {
    151. 
  
  
  
  151.                             e.printStackTrace();
    152. 
  
  
  
  152.                             value = -1L;
    153. 
  
  
  
  153.                         }
    154. 
  
  
  
  154.                         m.invoke(object, value);
    155. 
  
  
  
  155.                     }  
    156. 
  
  
  
  156.                 } catch (Exception e) {
    157. 
  
  
  
  157.                     // TODO: handle exception
    158. 
  
  
  
  158.                 }
    159. 
  
  
  
  159.             }
    160. 
  
  
  
  160.             return (T) object;
    161. 
  
  
  
  161.         } catch (Exception e) {
    162. 
  
  
  
  162.             e.printStackTrace();
    163. 
  
  
  
  163.         }
    164. 
  
  
  
  164. 
  
  
  
  165.         return null;
    166. 
  
  
  
  166.     }
    167. 
  
  
  
  167. 
  
  
  
  168. } 
    169.

这里需要注意一个坑，先来看一段代码

 
 
 
    
  
  
  
  1. class People {
    2. 
  
  
  
  2. 
  
  
  
  3.     private String name;
    4. 
  
  
  
  4.     private int age;
    5. 
  
  
  
  5.     private String mSex;
    6. 
  
  
  
  6. 
  
  
  
  7.     public String getName() {
    8. 
  
  
  
  8.         return name;
    9. 
  
  
  
  9.     }
    10. 
  
  
  
  10. 
  
  
  
  11.     public void setName(String name) {
    12. 
  
  
  
  12.         this.name = name;
    13. 
  
  
  
  13.     }
    14. 
  
  
  
  14. 
  
  
  
  15.     public int getAge() {
    16. 
  
  
  
  16.         return age;
    17. 
  
  
  
  17.     }
    18. 
  
  
  
  18. 
  
  
  
  19.     public void setAge(int age) {
    20. 
  
  
  
  20.         this.age = age;
    21. 
  
  
  
  21.     }
    22. 
  
  
  
  22. 
  
  
  
  23.     public String getmSex() {
    24. 
  
  
  
  24.         return mSex;
    25. 
  
  
  
  25.     }
    26. 
  
  
  
  26.     // 这里就出了问题  
    27. 
  
  
  
  27.     public void setmSex(String mSex) {
    28. 
  
  
  
  28.         this.mSex = mSex;
    29. 
  
  
  
  29.     }
    30. 
  
  
  
  30. 
  
  
  
  31. } 
    32.

当我们自动生成get set方法时，会将字段的首字母大写，我们在上面拼接set 方法时，也是基于这样的规则来拼装的。但是 当我们的字段名为 aAbbb 时，则生成的get set 方法则不会大写。解决方案也很简单，注意字段命名或者在拼接时对第二个自动进行大小写判断。这样我们自己写的Json解析工具就搞定， 以后每次解析只需一行代码即可OK。

新闻名称：Java高级特性之反射学习总结
当前链接：http://www.csdahua.cn/qtweb/news45/19745.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

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

成都快上网为您推荐相关内容

网站制作知识

同城分类信息

APP定制　　 　雪茄烟品牌　　 　德信企业管理　　 　成都做网站　　 　自适应网站设计　　 　外贸网站建设方案　　 　简阳服务器托管　　 　门户网站建设方案　　 　成都微信二次开发　　 　手机网站制作　　 　scfdjwx.com　　 　重庆水土三线托管　　 　网络营销　　 　网站报价方案　　 　建站定制开发　　 　亚克力背部发光字　　 　网站排名　　 　专业网站设计　　 　成都服务器托管　　 　做网站价格