JAVA深化篇_40—— 反射机制介绍
反射机制介绍
什么是反射
Java 反射机制是Java语言一个很重要的特性，它使得Java具有了“动态性”。在Java程序运行时，对于任意的一个类，我们能不能知道这个类有哪些属性和方法呢？对于任意的一个对象，我们又能不能调用它任意的方法？答案是肯定的！这种动态获取类的信息以及动态调用对象方法的功能就来自于Java 语言的反射（Reflection）机制。
反射的作用
简单来说两个作用，RTTI（运行时类型识别）和DC（动态创建）。
我们知道反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括其modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变fields内容或调用methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！
创建对象过程
Java创建对象的三个阶段
创建对象时内存结构
Users user = new Users();
实际上，我们在加载任何一个类时都会在方法区中建立“这个类对应的Class对象”，由于==“Class对象”包含了这个类的整个结构信息==，所以我们可以通过这个“Class对象”来操作这个类。
我们要使用一个类，首先要加载类；加载完类之后，在堆内存中，就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象知道类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以，我们形象的称之为：反射。 因此，“Class对象”是反射机制的核心。
反射的具体实现
获取Class对象的三种方式
- 通过getClass()方法;
- 通过.class 静态属性;
- 通过Class类中的静态方法forName();
创建Users类
public class Users {
private String username;
private int userage;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getUserage() {
return userage;
}
public void setUserage(int userage) {
this.userage = userage;
}
}
通过getClass()方法获取Class对象
/*
* 通过getClass()方法获取该类的Class对象
getClass()为Object类下的非静态方法，在使用时需要先实例化对象
*/
public class GetClass1 {
public static void main(String[] args) {
Users users = new Users();
Users users1 = new Users();
Class clazz = users.getClass();
System.out.println(clazz);
System.out.println(clazz.getName());
System.out.println(users.getClass() == users1.getClass());
}
}
通过forName()获取Class对象
/**
* 通过Class.forName("class Name")获取Class对象
*/
public class GetClass3 {
public static void main(String[] args)throws Exception {
Class clazz = Class.forName("com.java.Users");
Class clazz2 = Class.forName("com.java.Users");
System.out.println(clazz);
System.out.println(clazz.getName());
System.out.println(clazz == clazz2);
}
}
通过.class 静态属性获取Class对象
/**
* .class静态属性获取Class对象
*/
public class GetClass2 {
public static void main(String[] args) {
Class clazz = Users.class;
Class clazz2 = Users.class;
System.out.println(clazz);
System.out.println(clazz.getName());
System.out.println(clazz == clazz2);
}
}
获取类的构造方法
方法介绍
| 方法名 | 描述 |
|---|---|
| getDeclaredConstructors() | 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。 |
| getConstructors() | 返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共（public）构造方法。 |
| getConstructor(Class… parameterTypes) | 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共（public）构造方法。 |
| getDeclaredConstructor(Class… parameterTypes) | 返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 |
方法使用
修改Users类
public class Users {
private String username;
private int userage;
public Users(){
}
public Users(String username,int userage){
this.username= username;
this.userage=userage;
}
public Users(String username){
this.username= username;
}
private Users(int userage){
this.userage = userage;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getUserage() {
return userage;
}
public void setUserage(int userage) {
this.userage = userage;
}
}
获取构造方法
public class GetConstructor {
public static void main(String[] args)throws Exception {
Class clazz = Users.class;
Constructor[] arr = clazz.getDeclaredConstructors();
for(Constructor c:arr){
System.out.println(c);
}
System.out.println("---------------------");
Constructor[] arr1 = clazz.getConstructors();
for(Constructor c:arr1){
System.out.println(c);
}
System.out.println("------------------------");
Constructor c = clazz.getDeclaredConstructor(int.class);
System.out.println(c);
System.out.println("------------------------");
Constructor c1 = clazz.getConstructor(null);
System.out.println(c1);
}
}
通过构造方法创建对象 newInstance()
/**
**通过反射实例化对象
*/
public class GetConstructor2 {
public static void main(String[] args) throws Exception{
//创建类对象
Class<Users> usersClass = Users.class;
//通过类对象获取指定的构造方法对象
Constructor<Users> constructor = usersClass.getConstructor(String.class, int.class);
//通过指定的构造方法对象创建对象
Users users = constructor.newInstance("zhangsan", 20);
System.out.println(users);
}
}
获取类的成员变量
方法介绍
| 方法名 | 描述 |
|---|---|
| getFields() | 返回Field类型的一个数组,其中包含 Field对象的所有公共(public)字段。 |
| getDeclaredFields() | 返回Field类型的一个数组,其中包含 Field对象的所有字段。 |
| getField(String fieldName) | 返回一个公共成员的Field指定对象。 |
| getDeclaredField(String fieldName) | 返回一个 Field指定对象。 |
方法使用
修改Users类
public class Users {
private String username;
public int userage;
public Users(){
}
public Users(String username,int userage){
this.username= username;
this.userage=userage;
}
public Users(String username){
this.username= username;
}
private Users(int userage){
this.userage = userage;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getUserage() {
return userage;
}
public void setUserage(int userage) {
this.userage = userage;
}
}
获取成员变量
public class GetField {
public static void main(String[] args) throws Exception{
Class<Users> usersClass = Users.class;
Field[] fields = usersClass.getFields();
for(Field field:fields){
System.out.println(field);
}
System.out.println("===================");
Field[] declaredFields = usersClass.getDeclaredFields();
for(Field field:declaredFields){
System.out.println(field);
}
System.out.println("=================");
Field userName = usersClass.getDeclaredField("userName");
System.out.println(userName);
System.out.println("=================");
Field userAge = usersClass.getField("userAge");
System.out.println(userAge);
}
}
操作成员变量 先实例化对象
public class GetField2 {
public static void main(String[] args)throws Exception {
//获取Users类的类对象
Class<Users> usersClass = Users.class;
//获取类的成员变量
Field userAge = usersClass.getField("userAge");
//通过构造方法实例化users对象
Users users = usersClass.getConstructor(null).newInstance();
//给指定成员变量赋值
userAge.set(users,20);
System.out.println(userAge.get(users));
}
}
获取类的方法
方法介绍
| 方法名 | 描述 |
|---|---|
| getMethods() | 返回一个Method类型的数组,其中包含 所有公共(public)方法。包含父类中的（public）方法！！！！！ |
| getDeclaredMethods() | 返回一个Method类型的数组,其中包含 所有方法。 |
| getMethod(String name, Class… parameterTypes) | 返回一个公共的Method方法对象。 |
| getDeclaredMethod(String name, Class… parameterTypes) | 返回一个方法Method对象 |
方法使用
修改Users类
public class Users {
private String userName;
public int userAge;
private Users(String userName){
this.userName = userName;
}
public Users(String userName, int userAge){
this.userName = userName;
this.userAge = userAge;
}
public Users(){
}
public Users(int userAge){
this.userAge = userAge;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public int getUserAge() {
return userAge;
}
public void setUserAge(int userAge) {
this.userAge = userAge;
}
private void sing(){
System.out.println("zhangsan爱唱歌");
}
@Override
public String toString() {
return "Users{" +
"userName='" + userName + '\'' +
", userAge=" + userAge +
'}';
}
}
获取方法
public class GetMethod {
public static void main(String[] args) throws Exception{
Class<Users> usersClass = Users.class;
Method[] classMethods = usersClass.getMethods();
for(Method method : classMethods){
System.out.println(method);
System.out.println(method.getName());
}
System.out.println("----------------");
Method[] declaredMethods = usersClass.getDeclaredMethods();
for(Method method : declaredMethods){
System.out.println(method);
System.out.println(method.getName());
}
System.out.println("=================");
Method setUserAge = usersClass.getMethod("setUserAge", int.class);
System.out.println(setUserAge.getName());
System.out.println(setUserAge);
System.out.println("===============");
Method sing = usersClass.getDeclaredMethod("sing");
System.out.println(sing);
System.out.println(sing.getName());
}
}
调用方法 invoke( )
public class GetMethod2 {
public static void main(String[] args)throws Exception {
//实例化类对象
Class<Users> usersClass = Users.class;
Method setUserName = usersClass.getMethod("setUserName", String.class);
//实例化对象
Users users = usersClass.getConstructor(null).newInstance();
//通过setUserName赋值
setUserName.invoke(users,"zhangsan");
//通过getUserName获取值
Method getUserName = usersClass.getMethod("getUserName");
Object userName = getUserName.invoke(users);
System.out.println(userName);
}
}
获取类的其他信息
public class GetClassInfo {
public static void main(String[] args) {
Class<Users> usersClass = Users.class;
//获取包名
Package usersClassPackage = usersClass.getPackage();
System.out.println(usersClassPackage);
System.out.println(usersClassPackage.getName());
//获取类名
String usersClassName = usersClass.getName();
System.out.println(usersClassName);
//获取超类
Class<? super Users> superclass = usersClass.getSuperclass();
System.out.println(superclass.getName());
//获取所有接口
Class<?>[] classInterfaces = usersClass.getInterfaces();
for(Class interfaces:classInterfaces){
System.out.println(interfaces.getName());
}
}
}
反射机制的效率
由于Java反射是要解析字节码，将内存中的对象进行解析，包括了一些动态类型，而JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多！
接下来我们做个简单的测试来直接感受一下反射的效率。
反射机制的效率测试
public class Test {
public static void main(String[] args) throws Exception{
Class<?> aClass = Class.forName("com.itbaizhan.Users");
Object o = aClass.getConstructor(null).newInstance();
Method setUsername = aClass.getMethod("setUserName",String.class);
long reflectStart = System.currentTimeMillis();
for(int i =0;i<100000000;i++){
setUsername.invoke(o,"zhangsan");
}
long reflectEnd = System.currentTimeMillis();
long start = System.currentTimeMillis();
Users u =new Users();
for(int i=0;i<100000000;i++){
u.setUserName("zhangsan");
}
long end = System.currentTimeMillis();
System.out.println("反射执行时间："+(reflectEnd-reflectStart));
System.out.println("普通方式执行时间："+(end-start));
}
}
反射执行时间：169
普通方式执行时间：0
setAccessible方法
setAccessible()方法：
setAccessible是启用和禁用访问安全检查的开关。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查;默认值为false。
由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的。
public class Test2 {
public static void main(String[] args) throws Exception{
Class<Users> usersClass = Users.class;
Users users = usersClass.getConstructor(null).newInstance();
Field userName = usersClass.getDeclaredField("userName");
//忽略安全检查
userName.setAccessible(true);
userName.set(users,"zhangsan");
Object o = userName.get(users);
System.out.println(o);
Method sing = usersClass.getDeclaredMethod("sing");
//忽略安全检查
sing.setAccessible(true);
sing.invoke(users);
}
}
反射总结
- Java 反射机制是Java语言一个很重要的特性，它使得Java具有了==“动态性”。==
- 反射机制的优点：
- 更灵活。
- 更开放。
- 反射机制的缺点：
- 降低程序执行的效率。
- 增加代码维护的困难。
- 获取Class类的对象的三种方式：
- 运用getClass()。（非静态方法，需要先实例化）
- 运用.class 语法。
- 运用Class.forName()（最常被使用）。
- 反射机制的常见操作
- 动态加载类、动态获取类的信息（属性、方法、构造器）。
- 动态构造对象。
- 动态调用类和对象的任意方法。
- 动态调用和处理属性。
- 获取泛型信息。
- 处理注解。