反射相关类介绍

最新推荐文章于 2024-03-27 22:04:16 发布

叁柒

最新推荐文章于 2024-03-27 22:04:16 发布

阅读量1k

点赞数 26

CC 4.0 BY-SA版权

分类专栏： JavaSE 文章标签： java jvm 开发语言

本文链接：https://blog.youkuaiyun.com/m0_64102491/article/details/127017577

JavaSE 专栏收录该内容

12 篇文章

订阅专栏

优快云话题挑战赛第2期
参赛话题：学习笔记

反射相关类

1. Class类

1.1 基本介绍

Class也是类，因此也继承Object类
Class类对象不是new出来的，而是系统创建的
对于某个类的Class对象，在内存中只有一份，因为类只加载一次
每个类的实例都会记得自己是由那个Class实例所产生
通过Class对象可以完整地得到一个类的完整结构，通过一系列API
Class存放在堆中

1.2 Class类常用方法

我们直接看案例

String classAllPath = "com.zxy.Car";
//1 . 获取到 Car 类 对应的 Class 对象
//<?> 表示不确定的 Java 类型
Class<?> cls = Class.forName(classAllPath);
//2. 输出 cls
System.out.println(cls); //显示 cls 对象, 是哪个类的 Class 对象 com.zxy.Car
System.out.println(cls.getClass());//输出 cls 运行类型 java.lang.Class
//3. 得到包名
System.out.println(cls.getPackage().getName());//包名
//4. 得到全类名
System.out.println(cls.getName());
//5. 通过 cls 创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);//car.toString()
//6. 通过反射获取属性 brand
Field brand = cls.getField("brand");
System.out.println(brand.get(car));//宝马
//7. 通过反射给属性赋值
brand.set(car, "奔驰");
System.out.println(brand.get(car));//奔驰
//8 我希望大家可以得到所有的属性(字段)
System.out.println("=======所有的字段属性====");
Field[] fields = cls.getFields();
for (Field f : fields) {
System.out.println(f.getName());//名称
}

1.3 获取Class类对象

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，但有可能抛出找不到类的异常
已知具体的类，通过类的Class获取，该方式最为安全可靠，程序性能也最高
已知某个类的实例，调用该实例的getClass()方法获取Class对象
其他方式

ClassLoader cl = 对象.getClass().getClassLoader();

Class clazz = cl.loadClass(“类的全类名”)
基本数据类型

Class cls = 基本数据类型.class
基本数据类型对应的包装类

Class cls = 包装类.TYPE

1.4 哪些类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
interface：接口
数组
enum：枚举
annotation：注解
基本数据类型
void

2. 类加载

2.1 基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载

静态加载：编译时加载相关的类，如果，没有则报错，依赖性太强
动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错吗，降低了依赖性

2.2 类加载时机

当创建对象时，（new）//静态加载
当子类被加载时，父类也加载//静态加载
调用类中的静态成员时//静态加载
通过反射//动态加载

2.3 类加载过程

在这里插入图片描述

加载loading：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
连接Linking：将类的二级制数据合并到jre中。
初始化：jvm负责对类进行初始化，这里主要是指静态成员。

3. 通过反射获取类的信息结构

Class类

getName：获取全类名
getSimpleName：获取简单类名
getFields：获取所有public修饰的属性，包含本类及父类的
getDeclaredFields：获取本类中的所有属性
getMethods：获取所有public修饰的方法，包含本类及父类的
getDeclaredMethods：获取本类中的所有方法
getConstructors：获取本类所有public修饰的构造器
getDeclaredConstructors：获取本类中的所有构造器
getPackage：以package形式返回包信息
getSuperClass：以Class形式返回父类信息
getInterfaces：以Class[]形式返回父类信息
getAnnotations：以Annotation[]形式返回注解信息

Field类

getModifiers：以int形式返回修饰符

默认修饰符是0，public是1，private是2等等
getReturnType：以Class形式获取返回类型
getName：返回属性名

Method类

getModifiers：以int形式返回修饰符

默认修饰符是0，public是1，private是2等等
getReturnType：以Class形式获取返回类型
getName：返回方法名
getParameterTypes：以Class[]返回参数类型数组

Consturctor类

getModifiers：以int形式返回修饰符

默认修饰符是0，public是1，private是2等等
getName：返回构造器名（全类名）
getParameterTypes：以Class[]返回参数类型数组

4. 通过反射创建对象

方式一：调用类中的public修饰的无参构造器
方式二：调用类中的指定构造器
Class类相关方法
- newInstance: 调用类中的无参构造器，获取对应类的对象
- getConstructor:根据参数列表，获取对应的public构造器对象
- getDeclaredConstructors：根据参数列表获取对应的所有构造器
Constructor类相关方法
- setAccessible：爆破
- newInstance：调用构造器

class User { //User 类
private int age = 10;
private String name = "波波";
public User() {//无参 public
}
public User(String name) {//public 的有参构造器
this.name = name;
}
private User(int age, String name) {//private 有参构造器
this.age = age;
this.name = name;
}
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
}

//1. 先获取到 User 类的 Class 对象
Class<?> userClass = Class.forName("com.zxy.User");
//2. 通过 public 的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
//3. 通过 public 的有参构造器创建实例
/*
constructor 对象就是
public User(String name) {//public 的有参构造器
this.name = name;
}
*/
//3.1 先得到对应构造器
Constructor<?> constructor = userClass.getConstructor(String.class);
//3.2 创建实例，并传入实参
Object Jack = constructor.newInstance("Jack");
System.out.println("Jack=" + Jack);
//4. 通过非 public 的有参构造器创建实例
//4.1 得到 private 的构造器对象
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//4.2 创建实例
//暴破【暴力破解】 , 使用反射可以访问 private 构造器/方法/属性, 反射面前，都是纸老虎
constructor1.setAccessible(true);
Object user2 = constructor1.newInstance(100, "张三丰");
System.out.println("user2=" + user2);

5. 通过反射访问类中的成员

5.1 访问属性

//1. 得到 Student 类对应的 Class 对象
Class<?> stuClass = Class.forName("com.zxy.Student");
//2. 创建对象
Object o = stuClass.newInstance();//o 的运行类型就是 Student
System.out.println(o.getClass());//Student
//3. 使用反射得到 age 属性对象
Field age = stuClass.getField("age");
age.set(o, 88);//通过反射来操作属性
System.out.println(o);//
System.out.println(age.get(o));//返回 age 属性的值
//4. 使用反射操作 name 属性
Field name = stuClass.getDeclaredField("name");
//对 name 进行暴破, 可以操作 private 属性
name.setAccessible(true);
//name.set(o, "波波");
name.set(null, "波波~");//因为 name 是 static 属性，因此 o 也可以写出 null
System.out.println(o);
System.out.println(name.get(o)); //获取属性值
System.out.println(name.get(null));//获取属性值, 要求 name 是 static

5.2 访问方法

//1. 得到 Boss 类对应的 Class 对象
Class<?> bossCls = Class.forName("com.zxy.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到 hi 方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
hi.invoke(o, "波波~");
//4. 调用 private static 方法
//4.1 得到 say 方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
System.out.println(say.invoke(null, 200, "李四", '女'));