目录
Java反射是一种强大的编程机制，它允许程序在运行时检查和操作类、接口、字段和方法等元素。
一、定义
Java反射是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能被称为Java语言的反射机制。（反射允许对成员变量，成员方法和构造方法的信息进行编程访问）
二、获取class对象的三种方式
1、Class.forName("全类名")
源代码阶段使用 Class.forName("") 方式获取反射对象。
2、类名.class
当类名加载到了内存中，使用 类名.class 方式获取class反射对象。
3、对象.getClass()
当内存中 new 了一个类对象，处于运行阶段。则使用 对象.getClass() 方式获取反射对象。
三、案例
1、获取 class 反射对象三种方式
假设我们有 Student 对象
package com.angindem.myreflect1;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
代码案例：
package com.angindem.myreflect1;
public class MyReflectDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
/**
* 获取class对象的三种方式:
* 1.Class.forName("全类名")
* 2.类名.class
* 3.对象.getClass()
*/
// 1.第一种方式
// 全类名： 包名 + 类名
// 最为常用的
Class sClass1 = Class.forName("com.angindem.myreflect1.Student");
System.out.println(sClass1);
// 2.第二种方式
// 一般更多的是当作参数进行传递
Class sClass2 = Student.class;
System.out.println(sClass2);
System.out.println(sClass1 == sClass2);
// 3.第三种方式
// 当我们已经有了这个类的对象时，才可以使用
Student s = new Student("angindem", 18);
Class sClass3 = s.getClass();
System.out.println(sClass3);
System.out.println(sClass1 == sClass3);
}
}
2、利用反射获取构造方法
假设我们有 Student 对象
package com.angindem.myreflect2;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
public class Student {
private String name;
private int age;
private Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public Student(String name) {
this.name = name;
}
protected Student(int age) {
this.age = age;
}
}
代码案例：
package com.angindem.myreflect2;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class MyReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
/**
* Class 类中用于获取构造方法的方法
* Constructor<?>[] getConstructors()
* Constructor<?>[] getDeclaredConstructors()
* Constructor<?> getConstructor(Class<?>... parameterTypes)
* Constructor<?> getDeclaredConstructor(Class<?>... parameterTypes)
*
* Constructor类中用于创建对象的方法
* T newInstance(Object... initargs)
* setAccessible(boolean flag)
*/
// 1、获取 class 字节码文件对象
Class<?> clazz = Class.forName("com.angindem.myreflect2.Student");
// 2、获取所有公有构造器
// Constructor<?>[] cons = clazz.getConstructors();
// for (Constructor<?> con : cons){
// System.out.println(con);
// }
// 3、获取所有构造器（包括私有、受保护、默认、公有）
// Constructor<?>[] cons = clazz.getDeclaredConstructors();
// for (Constructor<?> con : cons){
// System.out.println(con);
// }
// 4、获取单个的构造器
Constructor<?> con1 = clazz.getDeclaredConstructor();
// System.out.println(con1);
Constructor<?> con2 = clazz.getDeclaredConstructor(String.class);
// System.out.println(con2);
Constructor<?> con3 = clazz.getDeclaredConstructor(int.class);
// System.out.println(con3);
//
Constructor<?> con4 = clazz.getDeclaredConstructor(String.class, int.class);
// System.out.println(con4);
// 获取权限修饰符
// int modifiers = con4.getModifiers();
// System.out.println(modifiers);
// 获取参数个数，获取参数的类型
// Parameter[] parameters = con4.getParameters();
// for (Parameter parameter : parameters) {
// System.out.println(parameter);
// }
// 通过反射构建对象，参数类型要符合构造函数的参数类型
// 小细节： getDeclaredConstructor 只能获取当前类中的构造器相关信息，当类中的构造器私有时，则无法进行调用
// 需要通过 setAccessible(true) 设置为 true，临时取消访问权限限制
con4.setAccessible(true); // 这种方式也称为：暴力反射
Student stu = (Student) con4.newInstance("angindem", 18);
System.out.println(stu);
}
}扩展：关于 Modifier 的 常量字段值
| 修饰符 | 值 | 十六进制表示 | 描述 |
| public | 1 | 0x0001 | 表示该成员（类、方法、字段等）对所有类都可见。 |
| private | 2 | 0x0002 | 表示该成员只能在定义它的类内部访问。 |
| protected | 4 | 0x0004 | 表示该成员在定义它的类、同一包中的类以及所有子类中可见。 |
| default | 0 | 0x0000 | 表示该成员在定义它的类和同一包中的类中可见（没有显式修饰符）。 |
| abstract | 1024 | 0x0400 | 表示该类是抽象类，不能被实例化。 |
| final | 16 | 0x0010 | 表示该类不能被继承，或者该方法不能被重写，或者该字段是常量。 |
| interface | 512 | 0x0200 | 表示该类是一个接口。 |
| static | 8 | 0x0008 | 表示该字段或方法是静态的，属于类本身而不是类的实例。 |
| transient | 128 | 0x0080 | 表示该字段在序列化时不会被序列化。 |
| volatile | 64 | 0x0040 | 表示该字段的值可能会被多个线程同时访问，每次访问都需要从主内存中读取。 |
| synchronized | 32 | 0x0020 | 表示该方法是同步的，同一时间只能被一个线程访问。 |
| native | 256 | 0x0100 | 表示该方法是本地方法，其实现用非 Java 语言编写。 |
3、利用反射获取成员变量
假设我们有 Student 对象
package com.angindem.myreflect3;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {
private String name;
private int age;
public String gender;
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
}
代码案例：
package com.angindem.myreflect3;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class MyReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
/**
* Class 类中用于获取成员变量的方法
* Field[] getFields() 返回所有公有成员变量对象的数组
* Field[] getDeclaredFields() 返回所有成员变量对象的数组
* Field getField(String name) 返回一个公有成员变量对象
* Field getDeclaredField(String name) 返回一个成员变量对象
*
* Field 类中用于创建对象的方法
* void set(Object obj,Object value) 为成员变量赋值
* Object get(Object obj) 获取成员变量的值
*/
// 1、获取 class 字节码文件对象
Class<?> clazz = Class.forName("com.angindem.myreflect3.Student");
// 2、获取公有的成员变量
// Field[] fields = clazz.getFields();
// for (Field field : fields){
// System.out.println(field);
// }
// 3、获取所有成员变量(包括 私有的)
// Field[] fields = clazz.getDeclaredFields();
// for (Field field : fields){
// System.out.println(field);
// }
// 获取单个成员的变量
Field name = clazz.getDeclaredField("name");
System.out.println(name);
// 获取成员变量的权限修饰符
int modifiers = name.getModifiers();
System.out.println(modifiers);
// 获取成员变量的名称
String n = name.getName();
System.out.println(n);
// 获取成员变量的类型
Class<?> type = name.getType();
System.out.println(type);
// 获取成员变量的值
Student stu = new Student("angindem", 18, "男");
name.setAccessible(true); // 暴力反射：临时取消访问权限
Object value = name.get(stu);
System.out.println(value);
// 修改对象里面记录的值
name.set(stu, "ang");
System.out.println(stu);
}
}4、利用反射获取成员方法
假设我们有 Student 对象
package com.angindem.myreflect4;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void sleep(){
System.out.println("sleep睡觉");
}
private void eat(String food){
System.out.println("在吃 " + food);
}
}
代码案例：
package com.angindem.myreflect4;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MyReflectDemo1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
/**
* Class 类中用于获取成员方法的方法
* Method[] getMethods() 返回所有的公有成员方法对象的数组，包括父类中的
* Method[] getDeclaredMethods() 返回所有的成员方法对象的数组，不包括父类中的
* Method getMethod(String name,Class<?>... parameterTypes) 返回一个公有成员方法对象
* Method getDeclaredMethod(String name,Class<?>... parameterTypes) 返回一个成员方法对象
*
* Method类中用于创建对象的方法
* Object invoke(Object obj,Object... args) 运行方法
* 参数一：用 obj 对象调用该方法
* 参数二：调用方法的传递的参数（如果没有就不写）
* 返回值：方法的返回值（如果没有就不写）
* 获取方法的修饰符
* 获取方法的名字
* 获取方法的形参
* 获取方法的返回值
* 获取方法的抛出的异常
*/
// 1、获取 class 字节码文件对象
Class<?> clazz = Class.forName("com.angindem.myreflect4.Student");
// 2、获取里面所有的方法对象(包含父类中所有的公共方法)
// Method[] methods = clazz.getMethods();
// for (Method method : methods) {
// System.out.println(method);
// }
// 3、获取里面所有的方法对象(不能获取父类的，但是可以获取本类中私有的方法)
// Method[] methods = clazz.getDeclaredMethods();
// for (Method method : methods) {
// System.out.println(method);
// }
// 获取指定的单一方法
Method m = clazz.getDeclaredMethod("eat", String.class);
System.out.println(m);
// 获取方法的修饰符
int modifiers = m.getModifiers();
System.out.println(modifiers);
// 获取方法的名字
String name = m.getName();
System.out.println(name);
// 获取方法的形参
Class<?>[] parameterTypes = m.getParameterTypes();
for (Class<?> parameterType : parameterTypes){
System.out.println(parameterType);
}
// 获取方法的抛出异常
Class<?>[] exceptionTypes = m.getExceptionTypes();
for (Class<?> exceptionType : exceptionTypes){
System.out.println(exceptionType);
}
// 获取方法的返回值
Class<?> returnType = m.getReturnType();
System.out.println(returnType);
/** Method类中用于创建对象的方法
* Object invoke(Object obj,Object... args) 运行方法
* 参数一：用 obj 对象调用该方法
* 参数二：调用方法的传递的参数（如果没有就不写）
* 返回值：方法的返回值（如果没有就不写）
*/
Student s = new Student();
// 参数一s：表示方法的调用者
// 参数“汉堡包”：表示在调用方法的时候传递的实际参数
m.setAccessible(true);
String result = (String) m.invoke(s, "汉堡包");
System.out.println(result);
}
}