• 用反射的方式获取父类中的所有属性和方法

    Java代码  收藏代码
    1. package com.syh.jdbc.reflection_super;  
    2.   
    3. /** 
    4.  * 父类 
    5.  * @author syh 
    6.  * 
    7.  */  
    8.   
    9. public class Parent {  
    10.   
    11.     public String publicField  = "1";  
    12.       
    13.     String defaultField = "2";   
    14.       
    15.     protected String protectedField = "3";  
    16.       
    17.     private String privateField = "4" ;  
    18.       
    19.     public void publicMethod() {  
    20.         System.out.println("publicMethod...");  
    21.     }  
    22.       
    23.     void defaultMethod() {  
    24.         System.out.println("defaultMethod...");  
    25.     }  
    26.       
    27.     protected void protectedMethod() {  
    28.         System.out.println("protectedMethod...");  
    29.     }  
    30.       
    31.     private void privateMethod() {  
    32.         System.out.println("privateMethod...");  
    33.     }  
    34.       
    35. }  



    Java代码  收藏代码
    1. package com.syh.jdbc.reflection_super;  
    2.   
    3. /** 
    4.  * 子类 
    5.  * @author syh 
    6.  * 
    7.  */  
    8.   
    9. public class Son extends Parent{  
    10.   
    11. }  



    Java代码  收藏代码
    1. package com.syh.jdbc.reflection_super;  
    2.   
    3. import java.lang.reflect.Field;  
    4.   
    5. import java.lang.reflect.InvocationTargetException;  
    6. import java.lang.reflect.Method;  
    7.   
    8. /** 
    9.  * 方法类 
    10.  * @author syh 
    11.  * 
    12.  */  
    13.   
    14. public class ReflectionUtils {  
    15.   
    16.     /** 
    17.      * 循环向上转型, 获取对象的 DeclaredMethod 
    18.      * @param object : 子类对象 
    19.      * @param methodName : 父类中的方法名 
    20.      * @param parameterTypes : 父类中的方法参数类型 
    21.      * @return 父类中的方法对象 
    22.      */  
    23.       
    24.     public static Method getDeclaredMethod(Object object, String methodName, Class<?> ... parameterTypes){  
    25.         Method method = null ;  
    26.           
    27.         for(Class<?> clazz = object.getClass() ; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
    28.             try {  
    29.                 method = clazz.getDeclaredMethod(methodName, parameterTypes) ;  
    30.                 return method ;  
    31.             } catch (Exception e) {  
    32.                 //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。  
    33.                 //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了  
    34.               
    35.             }  
    36.         }  
    37.           
    38.         return null;  
    39.     }  
    40.       
    41.     /** 
    42.      * 直接调用对象方法, 而忽略修饰符(private, protected, default) 
    43.      * @param object : 子类对象 
    44.      * @param methodName : 父类中的方法名 
    45.      * @param parameterTypes : 父类中的方法参数类型 
    46.      * @param parameters : 父类中的方法参数 
    47.      * @return 父类中方法的执行结果 
    48.      */  
    49.       
    50.     public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,  
    51.             Object [] parameters) {  
    52.         //根据 对象、方法名和对应的方法参数 通过反射 调用上面的方法获取 Method 对象  
    53.         Method method = getDeclaredMethod(object, methodName, parameterTypes) ;  
    54.           
    55.         //抑制Java对方法进行检查,主要是针对私有方法而言  
    56.         method.setAccessible(true) ;  
    57.           
    58.             try {  
    59.                 if(null != method) {  
    60.                       
    61.                     //调用object 的 method 所代表的方法，其方法的参数是 parameters  
    62.                     return method.invoke(object, parameters) ;  
    63.                 }  
    64.             } catch (IllegalArgumentException e) {  
    65.                 e.printStackTrace();  
    66.             } catch (IllegalAccessException e) {  
    67.                 e.printStackTrace();  
    68.             } catch (InvocationTargetException e) {  
    69.                 e.printStackTrace();  
    70.             }  
    71.           
    72.         return null;  
    73.     }  
    74.   
    75.     /** 
    76.      * 循环向上转型, 获取对象的 DeclaredField 
    77.      * @param object : 子类对象 
    78.      * @param fieldName : 父类中的属性名 
    79.      * @return 父类中的属性对象 
    80.      */  
    81.       
    82.     public static Field getDeclaredField(Object object, String fieldName){  
    83.         Field field = null ;  
    84.           
    85.         Class<?> clazz = object.getClass() ;  
    86.           
    87.         for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
    88.             try {  
    89.                 field = clazz.getDeclaredField(fieldName) ;  
    90.                 return field ;  
    91.             } catch (Exception e) {  
    92.                 //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。  
    93.                 //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了  
    94.                   
    95.             }   
    96.         }  
    97.       
    98.         return null;  
    99.     }     
    100.       
    101.     /** 
    102.      * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter 
    103.      * @param object : 子类对象 
    104.      * @param fieldName : 父类中的属性名 
    105.      * @param value : 将要设置的值 
    106.      */  
    107.       
    108.     public static void setFieldValue(Object object, String fieldName, Object value){  
    109.       
    110.         //根据 对象和属性名通过反射 调用上面的方法获取 Field对象  
    111.         Field field = getDeclaredField(object, fieldName) ;  
    112.           
    113.         //抑制Java对其的检查  
    114.         field.setAccessible(true) ;  
    115.           
    116.         try {  
    117.             //将 object 中 field 所代表的值 设置为 value  
    118.              field.set(object, value) ;  
    119.         } catch (IllegalArgumentException e) {  
    120.             e.printStackTrace();  
    121.         } catch (IllegalAccessException e) {  
    122.             e.printStackTrace();  
    123.         }  
    124.           
    125.     }  
    126.       
    127.     /** 
    128.      * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter 
    129.      * @param object : 子类对象 
    130.      * @param fieldName : 父类中的属性名 
    131.      * @return : 父类中的属性值 
    132.      */  
    133.       
    134.     public static Object getFieldValue(Object object, String fieldName){  
    135.           
    136.         //根据 对象和属性名通过反射 调用上面的方法获取 Field对象  
    137.         Field field = getDeclaredField(object, fieldName) ;  
    138.           
    139.         //抑制Java对其的检查  
    140.         field.setAccessible(true) ;  
    141.           
    142.         try {  
    143.             //获取 object 中 field 所代表的属性值  
    144.             return field.get(object) ;  
    145.               
    146.         } catch(Exception e) {  
    147.             e.printStackTrace() ;  
    148.         }  
    149.           
    150.         return null;  
    151.     }  
    152. }  



    Java代码  收藏代码
      1. package com.syh.jdbc.reflection_super;  
      2.   
      3. import static org.junit.Assert.*;  
      4.   
      5. import java.lang.reflect.Field;  
      6. import java.lang.reflect.Method;  
      7.   
      8. import org.junit.Test;  
      9.   
      10. /** 
      11.  * 测试类,用JUnit4 进行测试 
      12.  * @author syh 
      13.  * 
      14.  */  
      15.   
      16. public class ReflectionUtilsTest {  
      17.   
      18.     /** 
      19.      * 测试获取父类的各个方法对象 
      20.      */  
      21.       
      22.     @Test  
      23.     public void testGetDeclaredMethod() {  
      24.           
      25.         Object obj = new Son() ;  
      26.           
      27.         //获取公共方法名  
      28.         Method publicMethod = ReflectionUtils.getDeclaredMethod(obj, "publicMethod") ;  
      29.         System.out.println(publicMethod.getName());  
      30.           
      31.         //获取默认方法名  
      32.         Method defaultMethod = ReflectionUtils.getDeclaredMethod(obj, "defaultMethod") ;  
      33.         System.out.println(defaultMethod.getName());  
      34.           
      35.         //获取被保护方法名  
      36.         Method protectedMethod = ReflectionUtils.getDeclaredMethod(obj, "protectedMethod") ;  
      37.         System.out.println(protectedMethod.getName());  
      38.           
      39.         //获取私有方法名  
      40.         Method privateMethod = ReflectionUtils.getDeclaredMethod(obj, "privateMethod") ;  
      41.         System.out.println(privateMethod.getName());  
      42.     }  
      43.   
      44.     /** 
      45.      * 测试调用父类的方法 
      46.      * @throws Exception 
      47.      */  
      48.       
      49.     @Test  
      50.     public void testInvokeMethod() throws Exception {  
      51.         Object obj = new Son() ;  
      52.           
      53.         //调用父类的公共方法  
      54.         ReflectionUtils.invokeMethod(obj, "publicMethod", null , null) ;  
      55.           
      56.         //调用父类的默认方法  
      57.         ReflectionUtils.invokeMethod(obj, "defaultMethod", null , null) ;  
      58.           
      59.         //调用父类的被保护方法  
      60.         ReflectionUtils.invokeMethod(obj, "protectedMethod", null , null) ;  
      61.           
      62.         //调用父类的私有方法  
      63.         ReflectionUtils.invokeMethod(obj, "privateMethod", null , null) ;  
      64.     }  
      65.   
      66.     /** 
      67.      * 测试获取父类的各个属性名 
      68.      */  
      69.       
      70.     @Test  
      71.     public void testGetDeclaredField() {  
      72.           
      73.         Object obj = new Son() ;  
      74.           
      75.         //获取公共属性名  
      76.         Field publicField = ReflectionUtils.getDeclaredField(obj, "publicField") ;  
      77.         System.out.println(publicField.getName());  
      78.           
      79.         //获取公共属性名  
      80.         Field defaultField = ReflectionUtils.getDeclaredField(obj, "defaultField") ;  
      81.         System.out.println(defaultField.getName());  
      82.           
      83.         //获取公共属性名  
      84.         Field protectedField = ReflectionUtils.getDeclaredField(obj, "protectedField") ;  
      85.         System.out.println(protectedField.getName());  
      86.           
      87.         //获取公共属性名  
      88.         Field privateField = ReflectionUtils.getDeclaredField(obj, "privateField") ;  
      89.         System.out.println(privateField.getName());  
      90.           
      91.     }  
      92.   
      93.     @Test  
      94.     public void testSetFieldValue() {  
      95.           
      96.         Object obj = new Son() ;  
      97.           
      98.         System.out.println("原来的各个属性的值: ");  
      99.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));  
      100.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));  
      101.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));  
      102.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));  
      103.           
      104.         ReflectionUtils.setFieldValue(obj, "publicField", "a") ;  
      105.         ReflectionUtils.setFieldValue(obj, "defaultField", "b") ;  
      106.         ReflectionUtils.setFieldValue(obj, "protectedField", "c") ;  
      107.         ReflectionUtils.setFieldValue(obj, "privateField", "d") ;  
      108.           
      109.         System.out.println("***********************************************************");  
      110.           
      111.         System.out.println("将属性值改变后的各个属性值: ");  
      112.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));  
      113.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));  
      114.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));  
      115.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));  
      116.           
      117.     }  
      118.   
      119.     @Test  
      120.     public void testGetFieldValue() {  
      121.           
      122.         Object obj = new Son() ;  
      123.           
      124.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));  
      125.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));  
      126.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));  
      127.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));  
      128.     }  
      129.   
      130. }  
  • 相关阅读:
    操作系统学习笔记 003 安装SourceInsight
    操作系统学习笔记 002 安装NASM
    操作系统学习笔记 001 安装Ubuntu
    ATmega8仿真——键盘扫描的学习
    Open-Drain&Push-Pull
    ATmega8仿真——LED 数码管的学习
    SSD固态硬盘的GC与Trim
    前缀、中缀、后缀表达式
    动态规划解决01背包问题
    javascript 获取图片原始尺寸
  • 原文地址：https://www.cnblogs.com/exmyth/p/10332405.html
Copyright © 2020-2023  润新知