简单理解Java的反射

反射(reflect)：

　　JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

获取类对象：

 　　通过查询API得知：

　　

　　代码如下：

　　

1 package com.baidu.reflect.test;
 2 /**
 3  * 测试获取类对象
 4  * @author admin
 5  *
 6  */
 7 
 8 import static org.junit.Assert.*;
 9 
10 import org.junit.Test;
11 
12 import com.baidu.reflect.domain.People;
13 
14 public class Test01 {
15 
16     @Test
17     public void getClass01() throws Exception {
18         // 实例化对象获取
19         People p = new People();
20         Class poeple = p.getClass();
21         System.out.println(poeple);
22         // com.baidu.reflect.domain.People
23     }
24 
25     @Test
26     public void getClass02() throws Exception {
27         // className.class获取
28         Class people = People.class;
29         System.out.println(people);
30     }
31 
32     @Test
33     public void getClass03() throws Exception {
34         // 完全限定名获取
35         Class people = Class.forName("com.baidu.reflect.domain.People");
36         System.out.println(people);
37 
38     }
39 }      

获取构造方法：

　　API如下：

代码如下

1 package com.baidu.reflect.test;
 2 
 3 import java.lang.reflect.Constructor;
 4 
 5 import org.junit.Before;
 6 import org.junit.Test;
 7 
 8 /**
 9  * 通过反射获取构造方法
10  * 
11  * @author admin
12  *
13  */
14 public class Test02 {
15     // 初始化clazz对象
16     Class clazz = null;
17 
18     @Before
19     public void testObject() throws Exception {
20         // 获取类对象
21         clazz = Class.forName("com.baidu.reflect.domain.People");
22     }
23 
24     @Test
25     public void testGetConstructor01() throws Exception {
26         // 通过类对象获取无参构造
27         Constructor constructor = clazz.getConstructor();
28         // 通过构造获取实例
29         Object people = constructor.newInstance();
30         System.out.println(people);// People [name=null, age=0, sex=null]
31 
32     }
33 
34     @Test
35     public void testGetConstructor02() throws Exception {
36         // 无参构造可以直接获取实例
37         Object people = clazz.newInstance();
38         System.out.println(people);
39     }
40 
41     @Test
42     public void testGetConstructor03() throws Exception {
43         // 通过对象获有参构造
44         Constructor constructor = clazz.getConstructor(String.class, String.class);
45         // 获取对象的实例并设置参数
46         Object people = constructor.newInstance("张三", "男");
47         System.out.println(people);// People [name=张三, age=0, sex=男]
48     }
49 
50     @Test
51     public void testGetConstructor04() throws Exception {
52         // 通过对象获私有有参构造
53         Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, String.class);
54         // 设置访问权限
55         constructor.setAccessible(true);
56         // 获取对象的实例并设置参数
57         Object people = constructor.newInstance("张三", 23, "男");
58         System.out.println(people);// People [name=张三, age=23, sex=男]
59     }
60 
61 }      

获取成员方法：

　　查询API得知：

　　

　　代码如下

　　

1 package com.baidu.reflect.test;
 2 
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Method;
 5 
 6 import org.junit.Before;
 7 import org.junit.Test;
 8 
 9 import com.baidu.reflect.domain.People;
10 
11 /**
12  * 通过反射获取方法 对象
13  * 
14  * @author admin
15  *
16  */
17 public class Test03 {
18     // 初始化clazz对象
19     Class clazz = null;
20     People people = null;
21 
22     @Before
23     public void testObject() throws Exception {
24         // 获取类对象
25         clazz = Class.forName("com.baidu.reflect.domain.People");
26         // 向下转型
27         people = (People) clazz.newInstance();
28     }
29 
30     @Test
31     public void testGetMethod01() throws Exception {
32         // 通过类对象获取公共方法
33         Method setNameMethod = clazz.getMethod("setName", String.class);
34         // 设置方法参数
35         setNameMethod.invoke(people, "张三");
36         // 输出people [name=张三, age=0, sex=null]
37         System.out.println(people + "\r" + "------------");
38         // 同上
39         Method getNameMethod = clazz.getMethod("getName");
40         String name = (String) getNameMethod.invoke(people);
41         System.out.println(name);// 张三
42     }
43 
44     @Test
45     public void testGetMethod02() throws Exception {
46         // 通过类对象获取私有方法
47         Method getSayHiMethod = clazz.getDeclaredMethod("sayHi");
48         getSayHiMethod.setAccessible(true);
49         // 因为没有返回值：Hello reflect
50         getSayHiMethod.invoke(people);
51 
52     }
53 
54 }      

获取成员变量：

　　API:

　　

　　

　　代码：

　　

1 package com.baidu.reflect.test;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 import org.junit.Before;
 6 import org.junit.Test;
 7 
 8 import com.baidu.reflect.domain.People;
 9 
10 /**
11  * 通过反射获取成员变量
12  * 
13  * @author admin
14  *
15  */
16 public class Test04 {
17     // 初始化clazz对象
18     Class clazz = null;
19     People people = null;
20 
21     @Before
22     public void testObject() throws Exception {
23         // 获取类对象
24         clazz = Class.forName("com.baidu.reflect.domain.People");
25         // 向下转型
26         people = (People) clazz.newInstance();
27     }
28 
29     @Test
30     public void testGetField01() throws Exception {
31         // 通过类对象获取private field;
32         Field nameField = clazz.getDeclaredField("name");
33         nameField.setAccessible(true);
34         nameField.set(people, "张三");
35         System.out.println(people);// People [name=张三, age=0, sex=null]
36 
37     }
38 
39     @Test
40     public void testGetField02() throws Exception {
41         // 通过类对象获取public field
42         Field sexField = clazz.getField("sex");
43         sexField.set(people, "未知");
44         System.out.println(people);// People [name=null, age=0, sex=未知]
45 
46     }
47 
48 }      

 希望能给大家一个参考，也希望大家多多支持我。

查阅文献：    https://baike.baidu.com/item/JAVA反射机制/6015990?