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

俗话说：反射反射，程序猿的快乐。特意转载这篇文章，当做学习笔记

原文链接 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. }