使用Java反射机制实现访问其他类的私有方法

以前一直说，Java的私有方法只能类的内部使用，外部无权限访问，但是，一旦使用Java的反射机制，你就可以再外部实现对其他类的私有方法的访问，下面使用一段代码来说明这个问题。

首先是被反射的类的代码

view plain print ?

1. package com.bird.reflect;  
2.   
3. import java.util.List;  
4.   
5. /** 
6.  * @use 需要反射获取方法的类 
7.  * @author Bird 
8.  * 
9.  */  
10. public class Person {  
11.     public static String name = "bird";  
12.       
13.     public Person(){  
14.         System.out.println("Person");  
15.     }  
16.       
17.     public Person(String name){  
18.         System.out.println("Person name"+name);  
19.     }  
20.       
21.       
22.     public Person(String name, int password){  
23.         System.out.println("Person name  password"+name+password);  
24.     }  
25.       
26.     private Person(List list){  
27.         System.out.println("Person List");  
28.     }  
29.       
30.       
31. }  

下面是反射类，也就是使用代码，其中，调用上面类的私有方法的测试方法是Test4

view plain print ?

1. package com.bird.reflect;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. import org.junit.Test;  
8.   
9. /** 
10.  * @解析刚才的类的函数 
11.  * @author Bird 
12.  * 
13.  */  
14. public class Demo1 {  
15.     @SuppressWarnings({ "unchecked", "static-access" })  
16.     @Test  
17.     public void test() throws Exception{//反射无参构造函数  
18.         Class clazz = Class.forName("com.bird.reflect.Person");//装载Person类的字节码  
19.         Constructor c = clazz.getConstructor(null);//获得构造函数  
20.         Person p = (Person) c.newInstance(null);//调用构造函数获得实例  
21.           
22.         System.out.println(p.name);//访问他的变量  
23.     }  
24.       
25.     @Test  
26.     public void test2() throws Exception{//反射有参构造函数  
27.         Class clazz = Class.forName("com.bird.reflect.Person");//装载Person类的字节码  
28.         Constructor c = clazz.getConstructor(String.class);//得到参数为String的构造函数  
29.         Person p = (Person) c.newInstance("chen");  
30.           
31.         System.out.println(p.name);  
32.     }  
33.       
34.     @Test  
35.     public void test3() throws Exception{//  
36.         Class clazz = Class.forName("com.bird.reflect.Person");//装载Person类的字节码  
37.         Constructor c = clazz.getConstructor(String.class,int.class);//两个参数  
38.         Person p = (Person) c.newInstance("dwad",123);  
39.           
40.         System.out.println(p.name);  
41.     }  
42.       
43.     @Test  
44.     public void test4() throws Exception{//反射私有构造函数,获得私有构造函数使用权限  
45.         Class clazz = Class.forName("com.bird.reflect.Person");//装载Person类的字节码  
46.         Constructor c = clazz.getDeclaredConstructor(List.class);//调用私有方法  
47.         c.setAccessible(true);//暴力反射获得私有函数访问权限  
48.         Person p = (Person) c.newInstance(new ArrayList());  
49.           
50.         System.out.println(p.name);  
51.     }  
52.       
53.       
54.     public void test5() throws Exception{//获得无参构造函数，简单方便  
55.     Person p = (Person) Class.forName("com.bird.reflect.Person").newInstance();  
56.         System.out.println(p.name);  
57.     }  
58. }  

看样子反射的力量还是非常伟大的