java反射超详解
1.反射基础
java反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意一个对象，都能够知道它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
java反射机制主要提供以下这几个功能：
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所有的成员变量和方法
- 在运行时调用任意一个对象的方法
1.1class类
class类，class类也是一个实实在在的类，存在于jdk的java.lang包中。class类的实例表示java应用运行时的类(class ans enum)或接口(interface and annotation)（每个java类运行时都在jvm里表现为一个class对象，可通过类名.class、类型.getclass()、class.forname("类名")等方法获取class对象）。数组同样也被映射为为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 class 对象。
到这我们也就可以得出以下几点信息：
- class类也是类的一种，与class关键字是不一样的。
- 手动编写的类被编译后会产生一个class对象，其表示的是创建的类的类型信息，而且这个class对象保存在同名.class的文件中(字节码文件)。
- 每个通过关键字class标识的类，在内存中有且只有一个与之对应的class对象来描述其类型信息，无论创建多少个实例对象，其依据的都是用一个class对象。
- class类只存私有构造函数，因此对应class对象只能有jvm创建和加载。
- class类的对象作用是运行时提供或获得某个对象的类型信息，这点对于反射技术很重要(关于反射稍后分析)。
1.2类加载
1.类加载机制流程
2.类的加载
注：详细的类加载内容，看jvm板块。
2.反射的使用
2.1class对象的获取
在类加载的时候，jvm会创建一个class对象。class对象可以说是反射中最常见的。
获取class对象的方式的主要三种：
- 根据类名：类名.class
- 根据对象：对象.getclass()
- 根据全限定类名：class.forname(全限定类名)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class demo1main1 { public static void main(string[] args) throws exception { //获取class对象的三种对象 system.out.println("根据类名：\t" + user.class); system.out.println("根据对象：\t" + new user().getclass()); system.out.println("根据全限定类名：\t" + class.forname("demo1.user")); //常用的方法 class<user> userclass = user.class; system.out.println("获取全限定类名：\t" + userclass.getname()); system.out.println("获取类名：\t" + userclass.getsimplename()); system.out.println("实例化：\t" + userclass.newinstance()); }} |
输出结果：
|
1
2
3
4
5
6
|
根据类名： class demo1.user根据对象： class demo1.user根据全限定类名： class demo1.user获取全限定类名： demo1.user获取类名： user实例化： user{name='init', age=0} |
再来看看class类的方法：
-
tosting()
|
1
2
3
4
|
public string tostring() { return (isinterface() ? "interface " : (isprimitive() ? "" : "class ")) + getname();} |
tostring()方法能够将对象转换为字符串，tostring()首先判断class类型是否是接口类型，也就是说普通类和接口都能用class对象表示，然后在判断是否是基本数据类型，这里判断的都是基本数据类型和包装类，还有void类型。
-
getname()
获取类的全限定名称。（包括包名）即类的完整名称。
1.如果是引用类型。比如 string.class.getname()→java.lang.string
2.如果是基本数据类型。比如 byte.class.getname()→byte
3.如果是数组类型。比如 new object[3].getclass().getname()→[ljava.lang.object;
-
getsimplename()
获取类名（不包括包名）。
-
getcanonicalname()
获取全限定的类名(包括包名)。
-
togenericstring()
返回类的全限定名称，而且包括类的修饰符和类型参数信息。
-
forname()
根据类名获得一个class对象的引用，这个方法会使类对象进行初始化。
例如：class t = class.forname("java.lang.thread")就能够初始化一个thread线程对象。
在java中，一共有三种获取类实例的方式：
1.class.forname(java.lang.thread)
2.thread.class
3.thread.getclass()
-
newinstance()
创建一个类的实例，代表着这个类的对象。上面forname()方法对类进行初始化，newinstance方法对类进行实例化。使用该方法创建的类，必须带有无参的构造器。
-
getclassloader()
获取类加载器对象。
-
getinterfaces()
获取当前类实现的类或是接口，可能是多个，所以返回的是class数组。
-
isinterface()
判断class对象是否是表示一个接口。
-
getfields()
获得某个类的所有的公共（public）的字段，包括继承自父类的所有公共字段。 类似的还有getmethods和getconstructors。
-
getdeclaredfields
获得某个类的自己声明的字段，即包括public、private和proteced，默认但是不包括父类声明的任何字段。类似的还有getdeclaredmethods和getdeclaredconstructors。
getname、getcanonicalname与getsimplename的区别：
-
getsimplename：只获取类名. -
getname：类的全限定名，jvm中class的表示，可以用于动态加载class对象，例如class.forname。 -
getcanonicalname：返回更容易理解的表示，主要用于输出（tostring）或log打印，大多数情况下和getname一样，但是在内部类、数组等类型的表示形式就不同了。
例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.cry;public class test { private class inner{ } public static void main(string[] args) throws classnotfoundexception { //普通类 system.out.println(test.class.getsimplename()); //test system.out.println(test.class.getname()); //com.cry.test system.out.println(test.class.getcanonicalname()); //com.cry.test //内部类 system.out.println(inner.class.getsimplename()); //inner system.out.println(inner.class.getname()); //com.cry.test$inner system.out.println(inner.class.getcanonicalname()); //com.cry.test.inner //数组 system.out.println(args.getclass().getsimplename()); //string[] system.out.println(args.getclass().getname()); //[ljava.lang.string; system.out.println(args.getclass().getcanonicalname()); //java.lang.string[] //我们不能用getcanonicalname去加载类对象，必须用getname //class.forname(inner.class.getcanonicalname()); 报错 class.forname(inner.class.getname()); }} |
2.2constructor类及其用法
constructor类存在于反射包(java.lang.reflect)中，反映的是class 对象所表示的类的构造方法。
获取constructor对象是通过class类中的方法获取的，class类与constructor相关的主要方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| constructor | getconstructor(class<?>… parametertypes) | 返回指定参数类型、具有public访问权限的构造函数对象 |
| constructor<?>[] | getconstructors() | 返回所有具有public访问权限的构造函数的constructor对象数组 |
| constructor | getdeclaredconstructor(class<?>… parametertypes) | 返回指定参数类型、所有声明的（包括private）构造函数对象 |
| constructor<?>[] | getdeclaredconstructors() | 返回所有声明的（包括private）构造函数对象 |
| t | newinstance() | 调用无参构造器创建此 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
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
93
94
95
96
97
98
99
100
|
public class constructiontest implements serializable { public static void main(string[] args) throws exception { class<?> clazz = null; //获取class对象的引用 clazz = class.forname("com.example.javabase.user"); //第一种方法，实例化默认构造方法，user必须无参构造函数,否则将抛异常 user user = (user) clazz.newinstance(); user.setage(20); user.setname("jack"); system.out.println(user); system.out.println("--------------------------------------------"); //获取带string参数的public构造函数 constructor cs1 =clazz.getconstructor(string.class); //创建user user user1= (user) cs1.newinstance("hiway"); user1.setage(22); system.out.println("user1:"+user1.tostring()); system.out.println("--------------------------------------------"); //取得指定带int和string参数构造函数,该方法是私有构造private constructor cs2=clazz.getdeclaredconstructor(int.class,string.class); //由于是private必须设置可访问 cs2.setaccessible(true); //创建user对象 user user2= (user) cs2.newinstance(25,"hiway2"); system.out.println("user2:"+user2.tostring()); system.out.println("--------------------------------------------"); //获取所有构造包含private constructor<?> cons[] = clazz.getdeclaredconstructors(); // 查看每个构造方法需要的参数 for (int i = 0; i < cons.length; i++) { //获取构造函数参数类型 class<?> clazzs[] = cons[i].getparametertypes(); system.out.println("构造函数["+i+"]:"+cons[i].tostring() ); system.out.print("参数类型["+i+"]:("); for (int j = 0; j < clazzs.length; j++) { if (j == clazzs.length - 1) system.out.print(clazzs[j].getname()); else system.out.print(clazzs[j].getname() + ","); } system.out.println(")"); } }}class user { private int age; private string name; public user() { super(); } public user(string name) { super(); this.name = name; } /** * 私有构造 * @param age * @param name */ private user(int age, string name) { super(); this.age = age; this.name = name; } public int getage() { return age; } public void setage(int age) { this.age = age; } public string getname() { return name; } public void setname(string name) { this.name = name; } @override public string tostring() { return "user{" + "age=" + age + ", name='" + name + '\'' + '}'; }} |
输出结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
user{age=20, name='jack'}--------------------------------------------user1:user{age=22, name='hiway'}--------------------------------------------user2:user{age=25, name='hiway2'}--------------------------------------------构造函数[0]:private com.example.javabase.user(int,java.lang.string)参数类型[0]:(int,java.lang.string)构造函数[1]:public com.example.javabase.user(java.lang.string)参数类型[1]:(java.lang.string)构造函数[2]:public com.example.javabase.user()参数类型[2]:() |
关于constructor类本身一些常用方法如下(仅部分，其他可查api)：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| class | getdeclaringclass() | 返回 class 对象，该对象表示声明由此 constructor 对象表示的构造方法的类,其实就是返回真实类型（不包含参数） |
| type[] | getgenericparametertypes() | 按照声明顺序返回一组 type 对象，返回的就是 constructor对象构造函数的形参类型。 |
| string | getname() | 以字符串形式返回此构造方法的名称。 |
| class<?>[] | getparametertypes() | 按照声明顺序返回一组 class 对象，即返回constructor 对象所表示构造方法的形参类型 |
| t | newinstance(object… initargs) | 使用此 constructor对象表示的构造函数来创建新实例 |
| string | togenericstring() | 返回描述此 constructor 的字符串，其中包括类型参数。 |
栗子：
|
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
|
constructor cs3 = clazz.getdeclaredconstructor(int.class,string.class);system.out.println("-----getdeclaringclass-----");class uclazz=cs3.getdeclaringclass();//constructor对象表示的构造方法的类system.out.println("构造方法的类:"+uclazz.getname());system.out.println("-----getgenericparametertypes-----");//对象表示此 constructor 对象所表示的方法的形参类型type[] tps=cs3.getgenericparametertypes();for (type tp:tps) { system.out.println("参数名称tp:"+tp);}system.out.println("-----getparametertypes-----");//获取构造函数参数类型class<?> clazzs[] = cs3.getparametertypes();for (class claz:clazzs) { system.out.println("参数名称:"+claz.getname());}system.out.println("-----getname-----");//以字符串形式返回此构造方法的名称system.out.println("getname:"+cs3.getname());system.out.println("-----getogenericstring-----");//返回描述此 constructor 的字符串，其中包括类型参数。system.out.println("getogenericstring():"+cs3.togenericstring()); |
输出结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
-----getdeclaringclass-----构造方法的类:com.example.javabase.user-----getgenericparametertypes-----参数名称tp:int参数名称tp:class java.lang.string-----getparametertypes-----参数名称:int参数名称:java.lang.string-----getname-----getname:com.example.javabase.user-----getogenericstring-----getogenericstring():private com.example.javabase.user(int,java.lang.string) |
2.3field类及其用法
field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。
同样的道理，我们可以通过class类的提供的方法来获取代表字段信息的field对象，class类与field对象相关方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| field | getdeclaredfield(string name) | 获取指定name名称的(包含private修饰的)字段，不包括继承的字段 |
| field[] | getdeclaredfield() | 获取class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段 |
| field | getfield(string name) | 获取指定name名称、具有public修饰的字段，包含继承字段 |
| field[] | getfield() | 获取修饰符为public的字段，包含继承字段 |
栗子：
|
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
|
public class reflectfield { public static void main(string[] args) throws classnotfoundexception, nosuchfieldexception { class<?> clazz = class.forname("reflect.student"); //获取指定字段名称的field类,注意字段修饰符必须为public而且存在该字段, // 否则抛nosuchfieldexception field field = clazz.getfield("age"); system.out.println("field:"+field); //获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取 field fields[] = clazz.getfields(); for (field f:fields) { system.out.println("f:"+f.getdeclaringclass()); } system.out.println("================getdeclaredfields===================="); //获取当前类所字段(包含private字段),注意不包含父类的字段 field fields2[] = clazz.getdeclaredfields(); for (field f:fields2) { system.out.println("f2:"+f.getdeclaringclass()); } //获取指定字段名称的field类,可以是任意修饰符的自动,注意不包含父类的字段 field field2 = clazz.getdeclaredfield("desc"); system.out.println("field2:"+field2); }}class person{ public int age; public string name; //省略set和get方法}class student extends person{ public string desc; private int score; //省略set和get方法} 输出结果: field:public int reflect.person.agef:public java.lang.string reflect.student.descf:public int reflect.person.agef:public java.lang.string reflect.person.name================getdeclaredfields====================f2:public java.lang.string reflect.student.descf2:private int reflect.student.scorefield2:public java.lang.string reflect.student.desc |
上述方法需要注意的是，如果我们不期望获取其父类的字段，则需使用class类的getdeclaredfield/getdeclaredfields方法来获取字段即可，倘若需要连带获取到父类的字段，那么请使用class类的getfield/getfields，但是也只能获取到public修饰的的字段，无法获取父类的私有字段。下面将通过field类本身的方法对指定类属性赋值，代码演示如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//获取class对象引用class<?> clazz = class.forname("reflect.student");student st= (student) clazz.newinstance();//获取父类public字段并赋值field agefield = clazz.getfield("age");agefield.set(st,18);field namefield = clazz.getfield("name");namefield.set(st,"lily");//只获取当前类的字段,不获取父类的字段field descfield = clazz.getdeclaredfield("desc");descfield.set(st,"i am student");field scorefield = clazz.getdeclaredfield("score");//设置可访问，score是private的scorefield.setaccessible(true);scorefield.set(st,88);system.out.println(st.tostring());//输出结果：student{age=18, name='lily ,desc='i am student', score=88} //获取字段值system.out.println(scorefield.get(st));// 88 |
其中的set(object obj, object value) 方法是field类本身的方法，用于设置字段的值，而get(object obj)则是获取字段的值，当然关于field类还有其他常用的方法如下：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| void | set(object obj, object value) | 将指定对象变量上此 field 对象表示的字段设置为指定的新值。 |
| object | get(object obj) | 返回指定对象上此 field 表示的字段的值 |
| class<?> | gettype() | 返回一个 class 对象，它标识了此field 对象所表示字段的声明类型。 |
| boolean | isenumconstant() | 如果此字段表示枚举类型的元素则返回 true；否则返回 false |
| string | togenericstring() | 返回一个描述此 field（包括其一般类型）的字符串 |
| string | getname() | 返回此 field 对象表示的字段的名称 |
| class<?> | getdeclaringclass() | 返回表示类或接口的 class 对象，该类或接口声明由此 field 对象表示的字段 |
| void | setaccessible(boolean flag) | 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性 |
上述方法可能是较为常用的，事实上在设置值的方法上，field类还提供了专门针对基本数据类型的方法，如setint()/getint()、setboolean()/getboolean、setchar()/getchar()等等方法，这里就不全部列出了，需要时查api文档即可。需要特别注意的是被final关键字修饰的field字段是安全的，在运行时可以接收任何修改，但最终其实际值是不会发生改变的。
2.4method类及其用法
method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法）。
下面是class类获取method对象相关的方法：
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| method | getdeclaredmethod(string name, class<?>… parametertypes) | 返回一个指定参数的method对象，该对象反映此 class 对象所表示的类或接口的指定已声明方法。 |
| method[] | getdeclaredmethod | 返回 method 对象的一个数组，这些对象反映此 class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 |
| method | getmethod(string name, class<?>… parametertypes) | 返回一个 method 对象，它反映此 class 对象所表示的类或接口的指定公共成员方法。 |
| method[] | getmethods() | 返回一个包含某些 method 对象的数组，这些对象反映此 class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共成员方法。 |
在通过getmethods方法获取method对象时，会把父类的方法也获取到，如上的输出结果，把object类的方法都打印出来了。而getdeclaredmethod/getdeclaredmethods方法都只能获取当前类的方法。我们在使用时根据情况选择即可。下面将演示通过method对象调用指定类的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class clazz = class.forname("reflect.circle");//创建对象circle circle = (circle) clazz.newinstance();//获取指定参数的方法对象methodmethod method = clazz.getmethod("draw",int.class,string.class);//通过method对象的invoke(object obj,object... args)方法调用method.invoke(circle,15,"圈圈");//对私有无参方法的操作method method1 = clazz.getdeclaredmethod("drawcircle");//修改私有方法的访问标识method1.setaccessible(true);method1.invoke(circle);//对有返回值得方法操作method method2 =clazz.getdeclaredmethod("getallcount");integer count = (integer) method2.invoke(circle);system.out.println("count:"+count); |
输出结果：
|
1
2
3
|
draw 圈圈,count=15drawcirclecount:100 |
在上述代码中调用方法，使用了method类的invoke(object obj,object… args) 第一个参数代表调用的对象，第二个参数传递的调用方法的参数。这样就完成了类方法的动态调用。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| object | invoke(object obj, object… args) | 对带有指定参数的指定对象调用由此 method 对象表示的底层方法。 |
| class<?> | getreturntype() | 返回一个 class 对象，该对象描述了此 method 对象所表示的方法的正式返回类型，即方法的返回类型 |
| type | getgenericreturntype() | 返回表示由此 method 对象所表示方法的正式返回类型的 type 对象，也是方法的返回类型。 |
| class<?>[] | getparametertypes() | 按照声明顺序返回 class 对象的数组，这些对象描述了此 method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组 |
| type[] | getgenericparametertypes() | 按照声明顺序返回 type 对象的数组，这些对象描述了此 method 对象所表示的方法的形参类型的，也是返回方法的参数类型 |
| string | getname() | 以 string 形式返回此 method 对象表示的方法名称，即返回方法的名称 |
| boolean | isvarargs() | 判断方法是否带可变参数，如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。 |
| string | togenericstring() | 返回描述此 method 的字符串，包括类型参数。 |
getreturntype方法/getgenericreturntype方法都是获取method对象表示的方法的返回类型，只不过前者返回的class类型后者返回的type(前面已分析过)，type就是一个接口而已，在java8中新增一个默认的方法实现，返回的就参数类型信息
|
1
2
3
4
5
6
|
public interface type { //1.8新增 default string gettypename() { return tostring(); }} |
而getparametertypes/getgenericparametertypes也是同样的道理，都是获取method对象所表示的方法的参数类型，其他方法与前面的field和constructor是类似的。
到此这篇关于java反射超详细讲解的文章就介绍到这了,更多相关java反射内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/qq_45966440/article/details/119758723
