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
