反射
类加载
-
基本说明
ClassLoad_
反射机制是Java实现动态语言的关键，也就是通过反射实现类动态加载。
- 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
- 动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
- 举例说明
-
类加载时机
- 当创建对象时（new) //静态加载
- 当子类被加载时，父类也加载//静态加载
- 调用类中的静态成员时//静态加载
- 通过反射//动态加载
Class.forName("com22.test.Cat")
package com22.reflection.ClassLoad_;
import java.lang.reflect.*;
import java.util.Scanner;
/**
* @ClassName ClassLoad_
* @Description TODO
* @Author 甲柒
* @Date 2023/9/12 8:46
* @Version 1.0
**/
public class ClassLoad_ {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入key");
String key = scanner.next();
switch (key) {
case "1":
// Dog dog = new Dog();//静态加载类，依赖性很强
// dog.cry();
break;
case "2":
//反射-》动态加载
Class cls = Class.forName("Person");//加载Person类【动态加载】
Object o = cls.newInstance();
Method m = cls.getMethod("hi");
m.invoke(o);
System.out.println("ok");
break;
default:
System.out.println("do nothing...");
}
}
}
//因为new Dog() 是静态加载，因此必须编写Dog
//Person类是动态加载，所以，没有编写Person类也不会报错，只有当动态加载该类时，才会报错
//class Dog {
// public void cry() {
// System.out.println("灰太狼~~~嗷呜~~~~~");
// }
//}
//
//class Person {
// public void hi() {
// System.out.println("灰太狼：我一定会回来的~~~");
// }
//}-
类加载过程图
-
类加载各阶段完成任务
-
加载阶段
JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象
-
连接阶段——验证
- 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
- 包括：文件格式验证（是否以魔数oxcafebabe开头）、源数据验证、字节码验证和符号引用验证【举例说明】
- 可以考虑使用 -Xverify:none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。
-
连接阶段——准备
- JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0、0L、null、false等）。这些变量所使用的内存都将在方法区中进行分配
- 举例说明：ClassLoad02.java
package com22.reflection.ClassLoad_;
/**
* @ClassName ClassLoad02
* @Description 说明一个类加载的链接阶段-准备
* @Author 甲柒
* @Date 2023/9/12 10:09
* @Version 1.0
**/
public class ClassLoad02 {
public static void main(String[] args) {
}
}
class A {
//属性-成员变量-字段
//分析类加载的链接阶段-准备 属性是如何处
//1. n1 是实例属性, 不是静态变量，因此在准备阶段，是不会分配内存
//2. n2 是静态变量，分配内存 n2 是默认初始化 0 ,而不是 20
//3. n3 是 static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变 n3 = 30
public int n1 = 10;
public static int n2 = 20;
public static final int n3 = 30;
}-
连接阶段——解析
- 虚拟机将常量池内的符号引用替换为直接引用的过程
- 举例说明：
-
Initialization（初始化）
- 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行<clinit>()方法的过程。
- <clinit>()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。【ClassLoad03.java】
- 虚拟机会保证一个类的<clinit>()方法在多线程环境中去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕【debug源码】
ClassLoad03.java
package com22.reflection.ClassLoad_;
/**
* @ClassName ClassLoad03
* @Description 演示类加载——初始化阶段
* @Author 甲柒
* @Date 2023/9/12 11:12
* @Version 1.0
**/
public class ClassLoad03 {
public static void main(String[] args) throws ClassNotFoundException {
//分析
//1.加载B类，并生成B的class对象
//2.连接 num = 0
//3.初始化阶段
// 依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并合并
/*
clinit(){
System.out.println("B 的静态代码块被执行");
//num = 300;
num = 100;
}
合并num = 100;
* */
// B b = new B();
// System.out.println(B.num);//100，如果直接使用类的静态属性，也会导致类的加载
//在加载类的时候是有同步机制的，正因有同步机制，才能保证某个类在内存中只有一份class对象
B b = new B();
}
}
class B {
static {
System.out.println("B 的静态代码块被执行");
num = 300;
}
static int num = 100;
public B() {//构造器
System.out.println("B() 构造器被执行");
}
}运行结果
通过反射获取类的结构信息
-
第一组：java.lang.Class类
| getName | 获取全类名 |
| getSimpleName | 获取简单类名 |
| getFields | 获取所有public修饰的属性，包含本类以及父类的 |
| getDeclaredFields | 获取本类中所有属性 |
| getMethods | 获取所有public修饰的方法，包含本类以及父类 |
| getDeclaredMethods | 获取本类中所有方法 |
| getConstructors | 获取本类所有public修饰的构造器，包含本类以及父类 |
| getDeclaredConstructors | 获取本类中所有构造器 |
| getPackage | 以Packeage形式返回包信息 |
| getSuperClass | 以Class形式返回父类信息 |
| getInterfaces | 以Class[]形式返回接口信息 |
| getAnnotations | 以Annotation[]形式返回注解信息 |
-
第二组：java.lang.reflect.Field类
| getModifiers | 以int形式返回修饰符 【说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16】，public(1) + static(8) = 9 |
| getType | 以Class形式返回类型 |
| getName | 返回属性名 |
-
第三组：java.lang.reflect.Method类
| getModifiers | 以int形式返回修饰符 【说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16】，public(1) + static(8) = 9 |
| getReturnType | 以Class形式获取返回类型 |
| getName | 返回方法名 |
| getParameterTypes | 以Class[]返回参数类型数组 |
-
第四组：java.lang.reflect.Constructor类
| getModifiers | 以int形式返回修饰符 |
| getName | 返回构造器名（全类名） |
| getParameterTypes | 以Class[]返回参数类型数组 |
代码演示
package com22.reflection;
import org.junit.jupiter.api.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* @ClassName ReflectionUtils
* @Description 演示如何通过反射获取类的结构信息
* @Author 甲柒
* @Date 2023/9/12 15:18
* @Version 1.0
**/
public class ReflectionUtils {
public static void main(String[] args) {
}
//第二组方法
@Test
public void api_02() throws ClassNotFoundException {
//得到Class对象
Class<?> personCls = Class.forName("com22.reflection.Person");
// getDeclaredFields 获取本类中所有属性
// 规定 【说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16】
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName()
+ " 该属性的修饰符值=" + declaredField.getModifiers()
+ " 该属性的类型=" + declaredField.getType());
}
// getDeclaredMethods 获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("获取本类中所有方法=" + declaredMethod.getName()
+ " 该方法访问修饰符的值=" + declaredMethod.getModifiers()
+ " 该方法返回类型=" + declaredMethod.getReturnType());
//输出当前这个方法的形参数组情况
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该方法的形参类型=" + parameterType);
}
}
// getDeclaredConstructors 获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("====================================");
System.out.println("本类中所有的构造器=" + declaredConstructor.getName());//这里只是输出了名字
Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该构造器的形参类型=" + parameterType);
}
}
}
//第一组方法API
@Test
public void api_01() throws ClassNotFoundException {
//得到Class对象
Class<?> personCls = Class.forName("com22.reflection.Person");
// getName 获取全类名
System.out.println(personCls.getName());//com22.reflection.Person
// getSimpleName 获取简单类名
System.out.println(personCls.getSimpleName());//Person
// getFields 获取所有public修饰的属性，包含本类以及父类的
Field[] fields = personCls.getFields();
for (Field field : fields) {
System.out.println("本类及父类属性=" + field.getName());
}
// getDeclaredFields 获取本类中所有属性
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName());
}
// getMethods 获取所有public修饰的方法，包含本类以及父类
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println("获取所有public修饰的方法，包含本类以及父类=" + method.getName());
}
// getDeclaredMethods 获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("获取本类中所有方法=" + declaredMethod.getName());
}
// getConstructors 获取所有public修饰的构造器，包含本类以及父类
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("本类以及父类的构造器=" + constructor.getName());
}
// getDeclaredConstructors 获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("本类中所有的构造器=" + declaredConstructor.getName());//这里只是输出了名字
}
// getPackage 以Package形式返回包信息
System.out.println(personCls.getPackage());
// getSuperClass 以Class形式返回父类信息
Class<?> superclass = personCls.getSuperclass();
System.out.println("父类的class对象=" + superclass);
// getInterfaces 以Class[]形式返回接口信息
System.out.println("====================================");
Class<?>[] interfaces = personCls.getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println("接口信息=" + anInterface);
}
// getAnnotations 以Annotation[]形式返回注解信息
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("注解信息=" + annotation);
}
}
}
class A {
public String hobby;
public void hi() {
}
public A() {
}
}
interface IA {
}
interface IB {
}
//@Deprecated
class Person extends A implements IA, IB {
//属性
public String name;
protected static int age;
String job;
private double sal;
//构造器
public Person() {
}
public Person(String name) {
}
public Person(String name, int age) {
}
//方法
public void m1(String name, int age, double sal) {
}
protected String m2() {
return null;
}
void m3() {
}
private void m4() {
}
}运行结果不在演示
通过反射创建对象
- 方式一：调用类中的public修饰的无参构造器
- 方式二：调用类中的指定构造器
| newInstance | 调用类中的无参构造器，获取对应类的对象 |
| getConstructor(Class...clazz) | 根据参数列表，获取对应的构造器对象 |
| getDecalaredConstructor(Class..clazz) | 根据参数列表，获取对应的所有构造器对象 |
| setAccessible | 暴破 |
| newInstance(Object...obj) | 调用构造器 |
案例演示
package com22.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @ClassName ReflecCreateInstance
* @Description 演示通过反射机制创建实例
* @Author 甲柒
* @Date 2023/9/12 20:29
* @Version 1.0
**/
public class ReflecCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//1.先获取到User类的Class对象
Class<?> userClass = Class.forName("com22.reflection.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 jiaQi = constructor.newInstance("JiaQi");
System.out.println("JiaQi=" + jiaQi);
//4.通过非public的有参构造器创建实例
//4.1得到private的构造器对象
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//4.2创建实例
constructor1.setAccessible(true);//暴破【暴力破解】，使用反射可以访问private构造器/方法/属性，反射面前，都是纸老虎
Object user2 = constructor1.newInstance(100, "弼马温");
System.out.println("user2=" + user2);
}
}
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;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}运行结果
通过反射访问类中的成员
访问属性 ReflecAccessProperty.java
- 根据属性名获取Field对象
Field f = clazz对象.getDeclaredField(属性名);
- 暴破
f.setAccessible(true); //f是Field
- 访问
f.set(o,值); //o表示对象
syso(f.get(o)); //o表示对象
- 注意：如果是静态属性，则set和get中的参数o，可以写成null
案例演示
package com22.reflection;
import java.lang.reflect.Field;
/**
* @ClassName ReflecAccessProperty
* @Description 演示反射操作属性
* @Author 甲柒
* @Date 2023/9/12 21:36
* @Version 1.0
**/
public class ReflecAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
//1.得到Student类对应的Class对象
Class<?> stuClass = Class.forName("com22.reflection.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);//返回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是静态的才能写成null
}
}
class Student {//类
public int age;
private static String name;
public Student() {//构造器
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
" name=" + name +
'}';
}
}运行结果
访问方法
- 根据方法名和参数列表获取Method方法对象：
Method m = clazz.getDeclaredMethod(方法名, XX.class);
- 获取对象：Object o = clazz.newInstance();
- 暴破：m.setAccessible(true);
- 访问：Object returnValue = m.invoke(o, 实参列表);
- 注意：如果是静态方法，则invoke的参数o，可以写成null
案例演示
package com22.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @ClassName ReflecAccessMethod
* @Description 演示通过反射调用方法
* @Author 甲柒
* @Date 2023/9/12 22:50
* @Version 1.0
**/
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//1.得到Boss类对应的Class对象
Class<?> bossCls = Class.forName("com22.reflection.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);
//4.2 因为say方法是private，所以需要暴破
say.setAccessible(true);
System.out.println(say.invoke(o, 100, "柒柒柒", '男'));
//4.3 因为say方法是static的，还可以这样调用
System.out.println(say.invoke(null, 200, "hongHong", '女'));
//5. 在反射中如果方法有返回值，统一返回Object，但是他运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "qq", '女');
System.out.println("reVal 的运行类型=" + reVal.getClass());//String
}
}
class Boss {//类
public int age;
private static String name;
public Boss() {//无参构造器
}
private static String say(int n, String s, char c) {//静态方法
return n + " " + s + " " + c;
}
public void hi(String s) {//
System.out.println("hi " + s);
}
}运行结果
