反射
类加载器
类的加载
- 当我们的程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一个Class对象中
类的加载时机
创建类的实例。
类的静态变量，或者为静态变量赋值。
类的静态方法。
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
初始化某个类的子类。
直接使用java.exe命令来运行某个主类。
以上六种情况的任何一种，都可以导致JVM将一个类加载到方法区。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class Test {
public static void main(String[] args) throws Exception{
}
}
|
类加载器
类加载器：是负责将磁盘上的某个class文件读取到内存并生成Class的对象。
- Java中有三种类加载器，它们分别用于加载不同种类的class：
- 启动类加载器(Bootstrap ClassLoader)：用于加载系统类库
<JAVA_HOME>\bin目录下的class，例如：rt.jar。
- 扩展类加载器(Extension ClassLoader)：用于加载扩展类库
<JAVA_HOME>\lib\ext目录下的class。
- 应用程序类加载器(Application ClassLoader)：用于加载我们自定义类的加载器。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| public class Test {
public static void main(String[] args) {
ClassLoader c1 = Test.class.getClassLoader();
System.out.println(c1);
ClassLoader c2 = Student.class.getClassLoader();
System.out.println(c2);
ClassLoader c3 = String.class.getClassLoader();
System.out.println(c3);
System.out.println("====================委派机制=================");
System.out.println(c1.getParent());
System.out.println(c1.getParent().getParent());
}
}
|
反射的概述
反射的引入
- 问题：IDEA中的对象是怎么知道类有哪些属性，哪些方法的呢？
1
| 通过反射技术对象类进行了解剖得到了类的所有成员。
|
反射的概念
1
| 反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖并操作类中的所有成员(成员变量，成员方法，构造方法)
|
使用反射操作类成员的前提
反射在实际开发中的应用
1
2
| * 开发IDE(集成开发环境)，比如IDEA,Eclipse
* 各种框架的设计和学习 比如Spring，Hibernate，Struct，Mybaits....
|
Class对象的获取方式
1
2
3
4
| * 方式1: 通过类名.class获得
* 方式2：通过对象名.getClass()方法获得
* 方式3：通过Class类的静态方法获得： static Class forName("类全名")
* 每一个类的Class对象都只有一个。
|
1
2
3
4
5
6
7
8
| public class Student {
private String name;
public void method1(){
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| public class Test {
public static void main(String[] args) throws Exception{
Class<Student> c1 = Student.class;
System.out.println(c1);
Student stu = new Student();
Class<? extends Student> c2 = stu.getClass();
System.out.println(c2);
Class<?> c3 = Class.forName("com.itheima.demo2_Class对象的获取.Student");
System.out.println(c3);
System.out.println(c1 == c2);
System.out.println(c1 == c3);
}
}
|
Class类常用方法
1
2
3
| String getSimpleName(); 获得类名字符串：类名
String getName(); 获得类全名：包名+类名
T newInstance() ; 创建Class对象关联类的对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
Class c = Student.class;
System.out.println(c.getSimpleName());
System.out.println(c.getName());
Student stu = (Student) c.newInstance();
System.out.println(stu);
}
}
|
反射之操作构造方法
Constructor类概述
1
2
3
4
5
| 反射之操作构造方法的目的
* 获得Constructor对象来创建类的对象。
Constructor类概述
* 类中的每一个构造方法都是一个Constructor类的对象
|
通过反射获取类的构造方法
1
2
3
4
5
6
7
8
9
10
11
12
| Class类中与Constructor相关的方法
1. Constructor getConstructor(Class... parameterTypes)
* 根据参数类型获得对应的Constructor对象。
* 只能获得public修饰的构造方法
2. Constructor getDeclaredConstructor(Class... parameterTypes)
* 根据参数类型获得对应的Constructor对象
* 可以是public、protected、(默认)、private修饰符的构造方法。
3. Constructor[] getConstructors()
获得类中的所有构造方法对象，只能获得public的
4. Constructor[] getDeclaredConstructors()
获得类中的所有构造方法对象
可以是public、protected、(默认)、private修饰符的构造方法。
|
通过反射执行构造方法
1
2
3
4
5
| Constructor对象常用方法
1. T newInstance(Object... initargs)
根据指定的参数创建对象
2. void setAccessible(true)
设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
|
示例代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| public class Student {
public String name;
public int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name) {
this.name = name;
}
private Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
| public class Test {
public static void main(String[] args) throws Exception{
Class<Student> c = Student.class;
Constructor<Student> con1 = c.getDeclaredConstructor();
System.out.println(con1);
Constructor<Student> con2 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(con2);
Constructor<Student> con3 = c.getDeclaredConstructor(int.class);
System.out.println(con3);
System.out.println("================================");
Constructor<?>[] arr1 = c.getDeclaredConstructors();
for (Constructor<?> con : arr1) {
System.out.println(con);
}
System.out.println("================================");
Student stu1 = con1.newInstance();
System.out.println(stu1);
Student stu2 = con2.newInstance("张三", 18);
System.out.println(stu2);
con3.setAccessible(true);
Student stu3 = con3.newInstance(19);
System.out.println(stu3);
}
}
|
反射之操作成员方法
Method类概述
1
2
3
4
| 反射之操作成员方法的目的
* 操作Method对象来调用成员方法
Method类概述
* 每一个成员方法都是一个Method类的对象。
|
通过反射获取类的成员方法
1
2
3
4
5
6
7
8
9
10
11
12
| Class类中与Method相关的方法
* Method getMethod(String name,Class...args);
* 根据方法名和参数类型获得对应的构造方法对象，只能获得public的
* Method getDeclaredMethod(String name,Class...args);
* 根据方法名和参数类型获得对应的构造方法对象，包括public、protected、(默认)、private的
* Method[] getMethods();
* 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
* Method[] getDeclaredMethods();
* 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的
|
通过反射执行成员方法
1
2
3
4
5
6
| Method对象常用方法
* Object invoke(Object obj, Object... args)
* 调用指定对象obj的该方法
* args：调用方法时传递的参数
* void setAccessible(true)
设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消
|
示例代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| public class Student {
public void show1() {
System.out.println("show1 方法...");
}
public void show2(int num) {
System.out.println("show2 方法...num: " + num);
}
private void show3() {
System.out.println("show3 方法...");
}
private void show4(String str) {
System.out.println("show1 方法...str: " + str);
}
public int show5(int num) {
System.out.println("show5 方法...num: " + num);
return 100;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
| public class Test {
public static void main(String[] args) throws Exception {
Class<Student> c = Student.class;
Method m1 = c.getDeclaredMethod("show1");
System.out.println(m1);
Method m2 = c.getDeclaredMethod("show2", int.class);
System.out.println(m2);
Method m3 = c.getDeclaredMethod("show3");
System.out.println(m3);
Method m4 = c.getDeclaredMethod("show4", String.class);
System.out.println(m4);
Method m5 = c.getDeclaredMethod("show5", int.class);
System.out.println(m5);
System.out.println("==============================");
Method[] arr = c.getDeclaredMethods();
for (Method m : arr) {
System.out.println(m);
}
System.out.println("==============================");
Student stu = c.newInstance();
m1.invoke(stu);
m2.invoke(stu,10);
m3.setAccessible(true);
m3.invoke(stu);
m4.setAccessible(true);
m4.invoke(stu,"itheima");
Object res = m5.invoke(stu, 20);
System.out.println(res);
}
}
|
invoke方法理解
数据：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| /**
* 反射测试类
* @author nbchen
* @date 2019/08/01
*/
public class ReflectClass {
/**
* 反射测试方法,接收字符串数组,遍历输出
* @param arg
*/
public void reflectMethod(String[] arg) {
for (String s : arg) {
System.out.println(s);
}
}
}
|
测试：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| /**
* 测试反射中的invoke方法
* @author nbchen
* @date 2019/08/01
*/
public class TestInvoke {
@Test
public void test() throws Exception {
// 获取字节码对象
Class<ReflectClass> clazz = (Class<ReflectClass>) Class.forName("com.nbchen.invoke.ReflectClass");
// 获取一个对象
Constructor<ReflectClass> con = clazz.getConstructor();
ReflectClass instance = con.newInstance();
String[] testArr = new String[]{"aa","bb"};
// 获取Method对象
Method method = clazz.getMethod("reflectMethod",String[].class);
// 调用invoke方法
/**
* 报错：java.lang.IllegalArgumentException: wrong number of arguments
*/
// method.invoke(instance,testArr);
// 解决办法1
// method.invoke(instance, (Object) testArr);
// 解决办法2
method.invoke(instance, new Object[]{testArr});
}
}
|
小结：
invoke方法的参数，
第一个参数是一个Object类型，也就是调用该方法的对象，
第二个参数是一个可变参数类型，这个可变参数类型怎么能传递给一个数组类型呢？一个是多个参数。一个是一个数组参数，显然参数的个数不匹配，怎么解决呢？
解决办法就是将可变参数变成一个参数：
1.将传递进去的s强转为Object类型
2.将s重新包装成一个Object数组
扩展反射操作成员方法案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| public class Test {
public static void main(String[] args)throws Exception {
Class<Student> c = Student.class;
Constructor<?>[] cons = c.getDeclaredConstructors();
Student stu = null;
for (Constructor<?> con : cons) {
stu = (Student) con.newInstance();
}
Method[] methods = c.getDeclaredMethods();
for (Method m : methods) {
if (m.getName().equals("show1")){
m.invoke(stu);
}
if (m.getName().equals("show2")){
m.invoke(stu,10);
}
if (m.getName().equals("show5")){
Object res = m.invoke(stu, 20);
System.out.println(res);
}
}
}
}
|
反射之操作成员变量【自学】
Field类概述
1
2
3
4
5
| 反射之操作成员变量的目的
* 通过Field对象给对应的成员变量赋值和取值
Field类概述
* 每一个成员变量都是一个Field类的对象。
|
通过反射获取类的成员变量
1
2
3
4
5
6
7
8
9
| Class类中与Field相关的方法
* Field getField(String name);
* 根据成员变量名获得对应Field对象，只能获得public修饰
* Field getDeclaredField(String name);
* 根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
* Field[] getFields();
* 获得所有的成员变量对应的Field对象，只能获得public的
* Field[] getDeclaredFields();
* 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的
|
通过反射访问成员变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Field对象常用方法
void set(Object obj, Object value)
void setInt(Object obj, int i)
void setLong(Object obj, long l)
void setBoolean(Object obj, boolean z)
void setDouble(Object obj, double d)
Object get(Object obj)
int getInt(Object obj)
long getLong(Object obj)
boolean getBoolean(Object ob)
double getDouble(Object obj)
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。
|
setXxx方法都是给对象obj的属性设置使用，针对不同的类型选取不同的方法。
getXxx方法是获取对象obj对应的属性值的，针对不同的类型选取不同的方法。
示例代码
1
2
3
4
5
| public class Student {
public String name;
private int age;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
| public class Test {
public static void main(String[] args) throws Exception{
Class<Student> c = Student.class;
Student stu = c.newInstance();
Field f1 = c.getDeclaredField("name");
System.out.println(f1);
Field f2 = c.getDeclaredField("age");
System.out.println(f2);
System.out.println("===============================");
Field[] arr = c.getDeclaredFields();
for (Field field : arr) {
System.out.println(field);
}
System.out.println("===============================");
System.out.println(f1.getType());
System.out.println(f2.getType());
System.out.println("===============================");
f1.set(stu,"张三" );
f2.setAccessible(true);
f2.set(stu,18 );
System.out.println("===============================");
System.out.println(f1.get(stu));
System.out.println(f2.get(stu));
}
}
|
微信
支付宝
