分享程序员开发的那些事...
更新时间：2022-10-07 21:18:08
java的反射机制一共分为上下两篇,上篇请参考:http://xinsz08.blog.51cto.com/10565212/1946912
下篇主要讲解:
1.利用反射技术获取构造方法,并使用构造方法创建对象
2.使用反射技术快速创建对象
3.使用反射技术获取成员方法,并执行方法
4.反射技术小结.
1.使用反射技术获取构造方法,并使用构造方法创建对象
实现步骤:
1.获取class文件对象 (Class.forName)
2.使用class文件对象中的方法,解剖class文件获取构造方法Constructor
3.使用构造方法Constructor中的方法newInstance执行构造方法创建对象
使用反射能够获取的构造方法:(首先建立一个Person类,用于测试,见代码实例1)
* public Person() 无参构造方法
* public Person(String name, int age, String sex) 全参构造方法
* private Person(String name, int age) 私有构造方法
代码实例1-创建Person 类:
|
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
|
package cn.xins08.boke;
public class Person {
private String name;
private int age;
public String sex;
static {
System.out.println("静态代码块");
}
// 3.无参的构造方法
public Person() {
super();
System.out.println("无参构造方法");
}
public Person(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
System.out.println("满参数构造方法");
}
private Person(String name, int age) {
super();
this.name = name;
this.age = age;
System.out.println("私有的构造方法");
}
// 4.toString方法
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
private void method() {
System.out.println("私有的method方法");
}
// 2.公共的setter/getter方法
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
} |
2.利用反射技术获取Person类的构造方法及创建对象:
代码实例2:
|
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
|
package cn.xins08.boke;
import java.lang.reflect.Constructor;
import cn.xins08.boke.Person;
public class ReflectConstructor {
public static void main(String[] args) throws Exception {
//1.获取class文件对象
Class clazz = Class.forName("cn.xins08.boke.Person");
// 2.使用class文件对象中的方法,获取class文件构造方法
Constructor[] cons1 = clazz.getConstructors();
// 获取多个需要用getConstructors,前面用Constructor[]数组来接收.
// 获取一个用Constructor[] cons =clazz.getConstructor(); 只有一个就无需遍历
for (Constructor con : cons1) {
System.out.println(con);
}
System.out.println("-------------------------------");
Constructor[] cons2 = clazz.getDeclaredConstructors();
for(Constructor con:cons2){
System.out.println(con);
}
//3.使用构造方法Constructor中的方法newInstacnce执行构造方法创建对象
Constructor con1 = clazz.getConstructor();
Object obj1=con1.newInstance();
System.out.println(obj1);//无参构造方法 Person [name=null, age=0, sex=null]
Person p1=(Person) obj1;
p1.setName("xinsz08");
System.out.println(p1);//Person [name=xinsz08, age=0, sex=null]
}
} |
运行结果:
静态代码块
public cn.xins08.boke.Person()
public cn.xins08.boke.Person(java.lang.String,int,java.lang.String)
-------------------------------
public cn.xins08.boke.Person()
public cn.xins08.boke.Person(java.lang.String,int,java.lang.String)
private cn.xins08.boke.Person(java.lang.String,int) (私有方法)
无参构造方法
Person [name=null, age=0, sex=null]
Person [name=xinsz08, age=0, sex=null]
3.使用反射技术快速创建对象(重点)
使用反射技术快速创建对象的前提:
Person类中必须有无参构造方法
构造方法的修饰符不能是私有,建议使用public,因为public的权重比较高.
只针对无参构造
原理:使用class类中的方法 newInstance() ,创建此对象所表示的类的一个新实例.
代码实例3:
|
1
2
3
4
5
6
7
8
9
10
11
|
package cn.xins08.boke;
public class Reflect_3 {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("cn.xins08.boke.Person");
Object obj = clazz.newInstance();
System.out.println(obj);
}
} |
运行结果:
静态代码块
无参构造方法
Person [name=null, age=0, sex=null]
4.使用反射技术获取成员方法,并执行方法(重点):
实现步骤:
1.获取类的class文件对象
2.使用class文件对象中的方法,获取Method
method 有两个方法:
Method[] getMethods() 返回公共的成员方法,包括继承自父类的,重写接口的方法
Method[] getDeclaredMethods() 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法
代码实例4:
|
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
|
package cn.xins08.boke;
import java.lang.reflect.Method;
public class ReflectMethod {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("cn.xins08.boke.Person");
// 使用class 文件对象中的方法获取method
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method);
// 能够返回公共,默认访问和私有方法,但是获取不到继承的方法
}
System.out.println("======我是分割线==============");
Method[] methodsD = clazz.getDeclaredMethods();
for (Method method : methodsD) {
System.out.println(method);//
}
Object obj = clazz.newInstance();
Method getNameMethod = clazz.getMethod("getName");
System.out.println(getNameMethod);
/*
* 无参构造方法 public java.lang.String cn.xins08.boke.Person.getName()
*/
Object m1 = getNameMethod.invoke(obj);
System.out.println(m1);
Method setNameMethod = clazz.getMethod("setName", String.class);
Object m2 =setNameMethod.invoke(obj, "xinsz08");
System.out.println(m2);
//此处的setName 没有返回值,因为返回类型为void.所以m2的值为null
//我们再次获取name的值
m1=getNameMethod.invoke(obj);
System.out.println(m1); //此时打印的就是xinsz08
}
} |
反射机制小结:
利用反射机制获取Class文件对象:
三种方式:
通过Object类 getClass()方法获取 Class对象
通过类名.class 方式 获取 Class对象
通过反射的方式, Class.forName(String classname) 获取Class对象
2.通过反射， 获取类中的构造方法，并完成对象的创建.
获取指定的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取指定的public修饰的构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
获取指定的构造方法，包含私有的
获取所有的构造方法:
public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法
public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法，包含私有的
3. 通过反射获取类中的构造方法，并完成对象的创建:
基本步骤：
1.获取字节码文件对象
2.通过字节码文件对象 ，获取到指定的构造方法
getConstructor(参数);
3.通过构造方法，创建对象
public T newInstance(Object... initargs)
私有构造方法，创建对象
1. 获取字节码文件对象
2. 通过字节码文件对象 ，获取到指定的构造方法
getDeclaredConstructor (参数);
3.通过构造方法，创建对象
public T newInstance(Object... initargs)
4.通过反射，获取Class文件中的方法
获取指定的方法
public Method getMethod(String name, Class<?>... parameterTypes)
获取指定的public方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
获取指定的任意方法，包含私有的
获取所有的方法
public Method[] getMethods() 获取本类与父类中所有public 修饰的方法
ublic Method[] getDeclaredMethods()获取本类中所有的方法，包含私有的
通过反射，调用方法
基本步骤：
1.获取Class对象
2.获取构造方法，创建对象
3.获取指定的public方法
4.执行方法
本文转自xinsz08の平行时空博客51CTO博客，原文链接http://blog.51cto.com/xinsz08/1947327如需转载请自行联系原作者
维度2018