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

JAVA 专栏收录该内容
12 篇文章 0 订阅
俗话说:反射反射,程序猿的快乐。特意转载这篇文章,当做学习笔记
原文链接 http://931360439-qq-com.iteye.com/blog/938886
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. }  
  • 0
    点赞
  • 0
    评论
  • 2
    收藏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值