0%

Java反射

1 什么是反射

1)java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法。本质是JVM得到class对象后,再通过class对象进行反编译,从而获取对象的各种信息

2)java属于先编译再运行的语言,程序中对象的类型在编译器就确定下来了,而当程序在运行时可能需要动态加载某些类,这些类因为之前用不到,所以没有被加载到jvm。通过反射,可以在运行时动态的创建对象并调用其属性,不需要提前在编译期直到运行的对象是谁

2 反射的原理

Class对象的由来是将.class文件读入内存,并为之创建一个Class对象。

20201031013312441

3 反射的优缺点

1、优点:在运行时获得类的各种内容,进行反编译,对于Java这种先编译再运行的语言,能够让我们很方便的创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代码的链接,更加容易实现面向对象。

2、缺点:

(1)反射会消耗一定的系统资源,因此,如果不需要动态地创建一个对象,那么就不需要用反射;

(2)反射调用方法时可以忽略权限检查,因此可能会破坏封装性而导致安全问题。

4 获取Class对象的3种方式

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
public class ReflectDemo {

public static void main(String[] args) throws ClassNotFoundException {

/**
* 1. Object类的getClass方法
*/
Person p=new Person();
Class c1 = p.getClass();
System.out.println(c1);//class reflect.Person

Person p2=new Person();
Class c2 = p2.getClass();
System.out.println(c2);//class reflect.Person

/**
* 2. 数据类型的静态属性class
*/

Class<Person> c3 = Person.class;
System.out.println(c3);//class reflect.Person


System.out.println(String.class); //class java.lang.String
System.out.println(Integer.class);//class java.lang.Integer
System.out.println(int.class); //int

/**
* 3. Class类中的静态方法
*/

Class<?> c4 = Class.forName("reflect.Person");
System.out.println(c4);//class reflect.Person


}

}

5 通过Class对象获取构造方法

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
public class ReflectDemo2 {

public static void main(String[] args) throws Exception {
Person p=new Person();
Class<?> c = Class.forName("reflect.Person");


Constructor<?>[] constructors = c.getConstructors();
for (Constructor cc:constructors){
System.out.println(cc);//public reflect.Person() 公共构造方法
}

Constructor<?>[] constructors1 = c.getDeclaredConstructors();
for (Constructor cc2:constructors1){
System.out.println(cc2);
/**所有构造方法
* private reflect.Person(java.lang.String,int,java.lang.String)
* reflect.Person(java.lang.String,int)
* public reflect.Person()
*/
}

System.out.println("-----------");

/**
* 单个构造方法
*/
Constructor<?> constructor = c.getConstructor();//public reflect.Person()
Object instance = constructor.newInstance();
System.out.println(instance);//Person{name='null', age=0, address='null'}


// private构造方法访问失败
Constructor<?> constructor1 = c.getDeclaredConstructor(String.class, int.class, String.class);

//暴力访问
constructor1.setAccessible(true);

Object o = constructor1.newInstance("bibofu", 20, "CQU");
System.out.println(o);//Person{name='bibofu', age=20, address='CQU'}


}
}

6 通过Class对象获取成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {

Class<?> c = Class.forName("reflect.Person");

Field[] fields = c.getDeclaredFields();
for (Field f:fields){
System.out.println(f);
/**
* private java.lang.String reflect.Person.name
* int reflect.Person.age
* public java.lang.String reflect.Person.address
*/
}

Field name = c.getDeclaredField("name");
name.setAccessible(true);
System.out.println(name);//private java.lang.String reflect.Person.name


}
}

-------------本文结束感谢您的阅读-------------
Your support will be the driving force of my creation