什么是反射机制
Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键（在运行阶段可以改变其结构）
特点：
1、极大的提高了程序的灵活性和扩展性，降低模块的耦合性，提高自身的适应能力
2、通过反射机制可以让程序创建和控制任何类的对象，无需提前硬编码目标类
3、能够在运行时构造一个类的对象、判断一个类所具有的成员变量和方法、调用一个对象的方法（包括 private），可能会有安全隐患
4、是构建框架技术的基础所在，使用反射可以避免将代码写死在框架中
5、包含动态类型，而 JVM 不能对动态代码优化，所以效率会比较低
在Java中可以通过Reflection APIs在运行时动态生成class实体，通过Constructor创建类实例、Field访问成员属性、Method调用方法
Class类
在Java中，每个 class 都有一个相应的 Class 对象。在编译完成后，在生成的.class文件中，会产生一个Class对象，用于表示这个类的类型信息。
特点：
1、由系统创建Class类
2、同一个类的实例指向同一个Class对象
3、通过Class可以完整的得到一个类所有被加载的结构
4、Class类是Java反射的基础
获得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
|
public class MyReflect { public static void main(String[] args) throws ClassNotFoundException { Teacher t = new Teacher(); // 1、通过对象获得 Class c1 = t.getClass(); // 2、forName + 全限定名 获得 Class c2 = Class.forName("reflect.Teacher"); // 3、通过类名获得 Class c3 = Teacher.class; // 4、基本数据类型的Type属性获得 Class c4 = Double.TYPE; // 5、通过子类的Class对象获得 Class c5 = c1.getSuperclass(); }}class Person { String name; public Person() { }}class Teacher extends Person { public Teacher() { }} |
getXXX为获取 public 构造器、属性、方法
getDeclaredXXX 获取任意构造器、属性、方法(包括private)
setAccessible方法避开权限检测，用以访问权限不足的成员
以下不在赘述
准备：Person类以及Tercher子类
|
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
|
package reflect;class Person { public String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } public String greet(String name) { return "hello " + name + "."; }}class Teacher extends Person {} |
Constructor类
java.lang.reflect.Constructor类是java.lang.reflect.Executable类的直接子类，用于表示类的构造方法。通过Class对象的 getConstructors() 方法可以获得当前运行时类的构造方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class MyConstructor { public static void main(String[] args) throws Exception { Class<Person> c = (Class<Person>) Class.forName("reflect.Person");// Object person2 = c.newInstance(); //@Deprecated// System.out.println(person2); Constructor<Person> constructor = c.getConstructor(); Person person = constructor.newInstance(); System.out.println(person); // 获取 public 有参构造方法 Constructor<Person> constructor1 = c.getConstructor(String.class, int.class); Person person1 = constructor1.newInstance("JL", 18); System.out.println(person1); // 获取构造方法 Constructor<Person> constructor2 = c.getDeclaredConstructor(String.class, int.class); constructor2.setAccessible(true); Person person2 = constructor1.newInstance("JL", 18); System.out.println(person2.name); }} |
Field类
java.lang.reflect.Field类用于封装成员变量信息，调用Class对象的 getField() 或 getFields()等方法可以获得当前运行时类的成员变量
|
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 MyField { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.Person"); // 在Person类中，无参的构造方法不能省略 Object p = c.getConstructor().newInstance(); // 获取 public 成员变量 Field[] fields = c.getFields(); // 获取所有成员变量（包括 private) Field[] allFields = c.getDeclaredFields(); //获取指定名称public变量 Field f1 = c.getField("name"); // 成员变量set、get f1.set(p, "JL"); System.out.println(f1.get(p)); Field f2 = c.getDeclaredField("age"); // private int age // 忽略权限检查，使得 private 成员可以被访问 f2.setAccessible(true); f2.set(p, 18); System.out.println(f2.get(p)); }} |
Method类
java.lang.reflect.Method类是java.lang.reflect.Executable类的直接子类，用于封装成员方法的信息，调用Class对象的 getMethod() 方法或 getMethods() 方法可以获得当前运行时类的指定方法或所有方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class MyMethod { public static void main(String[] args) throws Exception { Class<Person> c = (Class<Person>) Class.forName("reflect.Person"); Person p = c.getConstructor().newInstance(); // 获取所有 public 方法 Method[] methods = c.getMethods(); // 获取 greet 方法 Method method1 = c.getMethod("greet", String.class); //执行 greet 方法 System.out.println(method1.invoke(p, "JL")); } }0 |
PS：主要简单说明反射的使用，关于类加载机制，性能分析等没有说明
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://www.cnblogs.com/whyha/p/13376827.html
