什么是类反射—原理?
☆什么是反射
(1)Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
(2)反射(Reflection)是Java程序开发语言的特征之一,它允许运行中的Java程序对自身进行检查, 也称自审,并能直接操作程序的内部属性。例如,使用它能获得Java类中各成员的名称并显示出来。
(3)Java的这一能力在实际应用中应用得很多,在其它的程序语言中根本就不存在这一特性。例如,Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。
(4)JavaBean是类反射的实际应用之一,它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架,基本上都会有反射的使用。
☆反射引例(HelloWorld、USB)
反射最大的好处就是解耦
最简单的类反射:(相当于HelloWorld)
一个ReflectionHelloWorld类演示:
package cn.hncu.reflect.test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 1、类反射使用的步骤:<br>
* (1)Class c=Class.forName("类全名:包名[.子包名].类名");<br>
* (2)调用c对象中的成员方法:Field(字段)、Method(方法)、Constructor(构造方法)、Modifier(静态方法和常量)<br>
* (3)遍历出所有信息<br>
*@author <a"283505495@qq.com">lxd</a>
*@version 1.0 2017-4-15 下午12:30:31
*@fileName ReflectionHelloWorld.java
*/
public class ReflectionHelloWorld {
public static void main(String[] args) {
try {
Class c=Class.forName("cn.hncu.reflect.test.UserModel");
/*
* 提供有关类或接口的单个字段信息,以及对他的动态访问权限
*/
Field[] flds=c.getDeclaredFields();
for(Field fild:flds){
System.out.println(fild);
}
System.out.println("------------------------");
/*
* 提供关于类的单个构造方法的信息以及对它的访问权限。得到的构造方法只能是public类型的。
*/
Constructor[] cons=c.getConstructors();
for(Constructor con:cons){
System.out.println(con);
}
System.out.println("------------------------");
/*
* 返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,
* 包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
*/
Method[] ms=c.getDeclaredMethods();
for(Method m:ms){
System.out.println(m);
}
System.out.println("------------------------");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
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
UserModel类:
package cn.hncu.reflect.test;
import java.io.Serializable;
/**
* 用户uuid,name
*@author <a"283505495@qq.com">lxd</a>
*@version 1.0 2017-3-20 下午1:56:33
*@fileName UserModel.java
*/
interface Intera{
public void aa();
}
public class UserModel implements Serializable{
private static final long serialVersionUID = 1L;
private String uuid;
private String name;
private int type;
private String pwd;
public UserModel(String uuid, String name, int type, String pwd) {
super();
this.uuid = uuid;
this.name = name;
this.type = type;
this.pwd = pwd;
}
public UserModel(String uuid, String name, int type) {
super();
this.uuid = uuid;
this.name = name;
this.type = type;
}
public UserModel(){
}
public void a(){
System.out.println("我是接口的抽象方法");
}
public String getUuid() {
return uuid;
}
public void setUuid(String uuid) {
this.uuid = uuid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
UserModel other = (UserModel) obj;
if (uuid == null) {
if (other.uuid != null)
return false;
} else if (!uuid.equals(other.uuid))
return false;
return true;
}
@Override
public String toString() {
return "ID:\t" + uuid + " , \t" + name + "\t , " + (type);
}
}
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
运行结果:
private static final long cn.hncu.reflect.test.UserModel.serialVersionUID
private java.lang.String cn.hncu.reflect.test.UserModel.uuid
private java.lang.String cn.hncu.reflect.test.UserModel.name
private int cn.hncu.reflect.test.UserModel.type
private java.lang.String cn.hncu.reflect.test.UserModel.pwd
------------------------
public cn.hncu.reflect.test.UserModel()
public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int)
public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int,java.lang.String)
------------------------
public java.lang.String cn.hncu.reflect.test.UserModel.toString()
public int cn.hncu.reflect.test.UserModel.hashCode()
public boolean cn.hncu.reflect.test.UserModel.equals(java.lang.Object)
public java.lang.String cn.hncu.reflect.test.UserModel.getName()
public int cn.hncu.reflect.test.UserModel.getType()
public void cn.hncu.reflect.test.UserModel.setName(java.lang.String)
public static long cn.hncu.reflect.test.UserModel.getSerialversionuid()
public java.lang.String cn.hncu.reflect.test.UserModel.getUuid()
public void cn.hncu.reflect.test.UserModel.setType(int)
public void cn.hncu.reflect.test.UserModel.setPwd(java.lang.String)
public void cn.hncu.reflect.test.UserModel.a()
public java.lang.String cn.hncu.reflect.test.UserModel.getPwd()
public void cn.hncu.reflect.test.UserModel.setUuid(java.lang.String)
------------------------
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
反射使用的三个步骤
用于反射的类,如Method,可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤:
第一步:获得你想操作的类的java.lang.Class对象。在运行中的Java程序中,用java.lang.Class类来描述类和接口等。
第二步:调用诸如getDeclaredMethods的方法,取得该类中定义的所有方法的列表。
第三步:使用反射的API来操作这些信息。
如下面这段代码:
Class c = Class.forName("java.lang.String");
Method ms[] = c.getDeclaredMethods();
System.out.println(ms[0].toString());
1
2
3
4
它将以文本方式打印出String中定义的第一个方法的原型。
获取Class对象的三种方式:
★ 方式一
通过对象的getClass方法进行获取。这种方式需要具体的类和该类的对象,以及调用getClass方法。
★ 方式二
任何数据类型(包括基本数据类型)都具备着一个静态的属性class,通过它可直接获取到该类型对应的Class对象。这种方式要使用具体的类,然后调用类中的静态属性class完成,无需调用方法,性能更好。
★ 方式三
通过Class.forName()方法获取。这种方式仅需使用类名,就可以获取该类的Class对象,更有利于扩展。
代码演示:
package cn.hncu.reflect.test;
import org.junit.Test;
/**
* 1、演示获取Class c对象的三种方法
*@author <a"283505495@qq.com">lxd</a>
*@version 1.0 2017-4-15 下午2:57:05
*@fileName ReflectGetClass.java
*/
public class ReflectGetClass {
/**
* 法1:通过对象---对象.getClass()来获取c(一个Class对象)
*/
@Test
public void get1(){
Person p=new Person("Jack", 23);
Class c=p.getClass();//来自Object方法
}
/**
* 法2:通过类(类型)---任何数据类型包括(基本数据类型)都有一个静态的属性class ,他就是c 一个Class对象
*/
@Test
public void get2(){
Class c=Person.class;
Class c2=int.class;
}
/**
* 法3:通过字符串(类全名 )---能够实现解耦:Class.forName(str)
*/
@Test
public void get3(){
try {
Class c=Class.forName("cn.hncu.reflect.test.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}