反射基础
首先来看一下最常规的创建对象的方式:
ObjectClass clazz = new ObjectClass();
当程序执行到new ObjectClass的时候，java虚拟机会加载ObjectClass.class文件，这个文件是由ObjectClass.java生成的，当java虚拟机将ObjectClass.class加载进内存后，内存中会存在一个class对象，这就是一个类加载变成对象的大致过程，具体详细过程可以参考一下这篇文章。
知道了这些，那什么才是反射呢？具体来说，在运行状态时，JVM中构造任何一个类的对象，反射都可以获取到任意一个对象所属的类信息，以及这个类的成员变量或者方法，并且能够调用任意一个对象的属性或者方法。因此java中的反射机制理解为java语言具备了动态加载对象以及对对象的基本信息进行剖析和使用的能力。
反射提供的功能包括：
- 在运行时判断一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时获取一个类定义的成员变量以及方法
- 在运行时调用任意一个对象的方法
- 生成动态代理
Class类详解
Class类，Class类也是一个实实在在的类，存在于JDK的java.lang包中。Class类的实例表示java应用运行时的类(class ans enum)或接口(interface and annotation)（每个java类运行时都在JVM里表现为一个class对象，可通过类名.class、类型.getClass()、Class.forName(“类名”)等方法获取class对象）。数组同样也被映射为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 class 对象。
public final class Class<T> implements java.io.Serializable,
GenericDeclaration,
Type,
AnnotatedElement {
private static final int ANNOTATION= 0x00002000;
private static final int ENUM = 0x00004000;
private static final int SYNTHETIC = 0x00001000;
private static native void registerNatives();
static {
registerNatives();
}
/*
* Private constructor. Only the Java Virtual Machine creates Class objects. //私有构造器，只有JVM才能调用创建Class对象
* This constructor is not used and prevents the default constructor being
* generated.
*/
private Class(ClassLoader loader) {
// Initialize final field for classLoader. The initialization value of non-null
// prevents future JIT optimizations from assuming this final field is null.
classLoader = loader;
}
因此我们可以得出以下几种结论：
- Class类也是类的一种，与class关键字是不一样的。
- 手动编写的类被编译后会产生一个Class对象，其表示的是创建的类的类型信息，而且这个Class对象保存在同名.class的文件中(字节码文件) 。
- 每个通过关键字class标识的类，在内存中有且只有一个与之对应的Class对象来描述其类型信息，无论创建多少个实例对象，其依据的都是用一个Class对象。
- Class类只存私有构造函数，因此对应Class对象只能有JVM创建和加载
- Class类的对象作用是运行时提供或获得某个对象的类型信息。
类加载
类的加载器
ava虚拟机的类加载器一共有三种，分别是启动类加载器（引导类加载器（根类加载器）：Bootstrap ClassLoader），扩展类加载器（Extension ClassLoader），应用程序类加载器（系统类加载器 AppClassLoader）。还有就是在java程序中，我们可以自行定义一个类加载器，这个类加载器被划分为自定义类加载器。详情请参考这篇文章
类的加载机制
类的加载机制一共有四种，分别是全盘负责机制，父类委托机制，缓存机制，还有最重要的双亲委派机制。详情请参考这篇文章
反射的使用场景
获取对象的包名以及类名
package FleshTest;
public class MyInvocation {
public static void main(String[] args) {
getClassNameTest();
}
public static void getClassNameTest(){
MyInvocation myInvocation = new MyInvocation();
System.out.println("class: " + myInvocation.getClass());
System.out.println("simpleName: " + myInvocation.getClass().getSimpleName());
System.out.println("name: " + myInvocation.getClass().getName());
System.out.println("package: " +
"" + myInvocation.getClass().getPackage());
}
}
结果：
1、getClass()：打印会带着class+全类名
2、getClass().getSimpleName()：只会打印出类名
3、getName()：会打印全类名
4、getClass().getPackage()：打印出package+包名
getClass()获取到的是一个对象，getPackage()也是。
Class类对象的获取
在java中，一切皆对象。java中可以分为两种对象，实例对象和Class对象。这里我们说的获取Class对象，其实就是第二种，Class对象代表的是每个类在运行时的类型信息，指和类相关的信息。比如有一个Student类，我们用Student student = new Student()，new一个对象出来，这个时候Student这个类的信息其实就是存放在一个对象中，这个对象就是Class类的对象，而student这个实例对象也会和Class对象关联起来。
import java.util.*;
import java.lang.reflect.*;
import java.lang.annotation.*;
// 定义可重复注解
@Repeatable(Annos.class)
@interface Anno {}
@Retention(value=RetentionPolicy.RUNTIME)
@interface Annos {
Anno[] value();
}
// 使用四个注解修饰该类
@SuppressWarnings(value="unchecked")
@Deprecated
// 使用重复注解修饰该类
@Anno
@Anno
public class ClassTest
{
// 定义一个私有构造器
private ClassTest()
{
}
// 定义一个有参数构造器
public ClassTest(String name)
{
System.out.println("执行有参数构造器");
}
// 定义一个无参数的info方法
public void info()
{
System.out.println("ִ执行无参数的info方法");
}
// 定义一个有参数的info方法
public void info(String str)
{
System.out.println("执行有参数的info方法"
+ "str值" + str);
}
// 定义一个测试用的内部类
class Inner
{
}
public static void main(String[] args)
throws Exception
{
// 下面代码可以获取 ClassTest 对应的 Class
Class<ClassTest> clazz = ClassTest.class;
//获取该 Class 对象所对应类的全部构造器
Constructor[] ctors = clazz.getDeclaredConstructors();
System.out.println("ClassTest 的全部构造器如下 : ");
for (Constructor c : ctors)
{
System.out.println(c);
}
//获取该 Class 对象所对应类的全部 public 构造器
Constructor[] publicCtors = clazz.getConstructors();
System.out.println("ClassTest 的全部 public 构造器如下:");
for (Constructor c : publicCtors)
{
System.out.println(c);
}
// ClassTest 的全部 public 构造器如下:
Method[] mtds = clazz.getMethods();
System.out.println(" ClassTest 的全部 public 方法如下: ");
for (Method md : mtds)
{
System.out.println(md);
}
// 获取该 Class 对象所对应类的指定方法
System.out.println("ClassTest 里带一个字符串参数的 info 方法为:"
+ clazz.getMethod("info" , String.class));
// 获取该 Class 对象所对应类的全部注解
Annotation[] anns = clazz.getAnnotations();
System.out.println("获取该 Class 对象所对应类的全部注解");
for (Annotation an : anns)
{
System.out.println(an);
}
System.out.println(" 该 Class 元素上自的甘 @S归uppressWarr川 n 呵9 归s 注解为:"
+ Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));
System.out.println("该 Class:元素上的@Anno 注解为 : "
+ Arrays.toString(clazz.getAnnotationsByType(Anno.class)));
// 该 Class :7ë素上的 @Anno 注解为 :
Class<?>[] inners = clazz.getDeclaredClasses();
System.out.println("ClassTest 的全部内部类如下 : ");
for (Class c : inners)
{
System.out.println(c);
}
// 使用 Class . forName() 方法加载 ClassTest 的 Inner 内部类
Class inClazz = Class.forName("ClassTest$Inner");
// 通过 getDeclaringClass() 访问该类所在的外部类
System.out.println("inClazz 对应类的外部类为 :" +
inClazz.getDeclaringClass());
System.out.println("inClazz 对应类的外部类为 :" + clazz.getPackage());
System.out.println("ClassTest 的父类为 :" + clazz.getSuperclass());
}
}
一共有三种方式可以获取一个类在运行时的Class对象，分别是：
- 使用Class类的forName()静态方法。该方法需要传入字符串参数，该字符串参数的值是某个类的全限定类名（必须添加完整包名）。比如：Class.forName(“com.Student”)
- 调用某个类的class属性来获取该类对应的Class对象。例如Person.class将会返回Person类对应的Class对象。
- 调用某个对象的getClass()方法，该方法是java.lang.Object类中的一个方法，所以所有Java对象都可以调用该方法，该方法将会返回该对象所属类对应的Class对象。比如：student.getClass()
实例代码：
package FleshTest;
/**
* @author: 随风飘的云
* @describe：类对象的获取
* @date 2022/08/22 16:21
*/
public class Student {
public static void getClassTest(){
Class<?> invocation1 = null;
Class<?> invocation2 = null;
Class<?> invocation3 = null;
// 第一种
try {
// 最常用的方法
invocation1 = Class.forName("FleshTest.Student");
}catch (Exception ex){
ex.printStackTrace();
}
// 第三种
invocation2 = new Student().getClass();
// 第二种
invocation3 = Student.class;
System.out.println(invocation1);
System.out.println(invocation2);
System.out.println(invocation3);
}
public static void main(String[] args) {
getClassTest();
}
}
结果：
再来看看 Class类的方法：
获取指定类型的实例化对象
构建Student类对象信息，后面的不再重复补充。
package FleshTest;
public class Student {
private int age;
private String name;
public Student() {
}
public Student(int age) {
this.age = age;
}
public Student(String name) {
this.name = name;
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
实例代码：
package FleshTest;
/**
* @author: 随风飘的云
* @describe：获取指定类型的实例化对象
* @date 2022/08/22 16:28
*/
public class MyInvocation2 {
public static void getInstanceTest() {
try {
Class<?> studentClass = Class.forName("FleshTest.Student");
Student student = (Student) studentClass.newInstance();
student.setAge(22);
student.setName("随风飘的云");
System.out.println(student);
}catch (Exception ex){
ex.printStackTrace();
}
}
public static void main(String[] args) {
getInstanceTest(); // 输出：Student{age=22, name='随风飘的云'}
}
}
如果说删掉上面Student类中的无参构造方法，那会发生什么呢？结果：
分析： 因为代码中重写了构造方法，而且是有参构造方法，如果不写构造方法，那么每个类都会默认有无参构造方法，重写了就不会有无参构造方法了，所以我们调用newInstance()的时候，会报没有这个方法的错误。值得注意的是，newInstance()是一个无参构造方法。
构造函数对象实例化对象
除了newInstance()方法之外，还可以通过构造函数对象获取实例化对象，怎么理解？这里只构造函数对象，而不是构造函数，也就是构造函数其实就是一个对象，我们先获取构造函数对象，当然也可以使用来实例化对象。
获取构造方法：
package FleshTest;
import java.lang.reflect.Constructor;
public class MyInvocation3 {
public static void testConstruct(){
try {
Class<?> student = Class.forName("FleshTest.Student");
Constructor<?> cons[] = student.getConstructors();
for(int i=0;i<cons.length;i++){
System.out.println(cons[i]);
}
}catch (Exception ex){
ex.printStackTrace();
}
}
public static void main(String[] args) {
testConstruct();
}
}
结果：
获取到了一个类的构造函数，那么就可以通过构造函数获取到它的各种信息，包括参数，参数个数，类型等等：
public static void testConstruct(){
try {
Class<?> student = Class.forName("FleshTest.Student");
Constructor<?> cons[] = student.getConstructors();
Constructor constructors = cons[0];
System.out.println("name: " + constructors.getName());
System.out.println("modifier: " + constructors.getModifiers());
System.out.println("parameterCount: " + constructors.getParameterCount());
System.out.println("构造参数类型如下：");
for (int i = 0; i < constructors.getParameterTypes().length; i++) {
System.out.println(constructors.getParameterTypes()[i].getName());
}
}catch (Exception ex){
ex.printStackTrace();
}
}
结果： modifier是权限修饰符，1表示为public，我们可以知道获取到的构造函数是两个参数的，第一个是int，第二个是String类型，看来获取出来的顺序应该是书写代码的顺序。
既然已经获取到了一个类的构造方法了，那么就可以通过这个方法进行构造对象：
public static void constructGetInstanceTest() {
try {
Class<?> stduent = Class.forName("FleshTest.Student");
Constructor<?> cons[] = stduent.getConstructors();
// 一共定义了4个构造器
Student student1 = (Student) cons[0].newInstance(22, "随风飘的云");
Student student2 = (Student) cons[1].newInstance("随风飘的云");
Student student3 = (Student) cons[2].newInstance(22);
Student student4 = (Student) cons[3].newInstance();
System.out.println(student1);
System.out.println(student2);
System.out.println(student3);
System.out.println(student4);
} catch (Exception ex) {
ex.printStackTrace();
}
}
结果： 
需要注意的是：构造器的顺序我们是必须一一针对的，要不会报一下的参数不匹配的错误：
// 一共定义了4个构造器
Student student1 = (Student) cons[3].newInstance(22, "随风飘的云");
Student student2 = (Student) cons[2].newInstance("随风飘的云");
Student student3 = (Student) cons[1].newInstance(22);
Student student4 = (Student) cons[0].newInstance();
结果：
获取类继承的接口
通过反射我们可以获取接口的方法，如果我们知道某个类实现了接口的方法，同样可以做到通过类名创建对象调用到接口的方法。
实例代码：
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
interface Animal {
public void Is_Alive();
}
interface PetClass {
public void PetName();
}
public class Cat implements Animal, PetClass{
@Override
public void Is_Alive() {
System.out.println("猫是活的");
}
@Override
public void PetName() {
System.out.println("猫可以作为宠物培养");
}
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("FleshTest.Cat");
Class<?>[] interfaces = clazz.getInterfaces();
for (Class c: interfaces) {
// 获取接口
System.out.println(c);
// 获取接口的方法
// 获取接口
System.out.println(c);
// 获取接口里面的方法
Method[] methods = c.getMethods();
// 遍历接口的方法
for (Method method : methods) {
// 通过反射创建对象
Cat cat = (Cat) clazz.newInstance();
// 通过反射调用方法
method.invoke(cat, null);
}
}
}
}
结果： 这样子可以获取到接口的数组，并且里面的顺序是我们继承的顺序，通过接口的Class对象，我们可以获取到接口的方法，然后通过方法反射调用实现类的方法，因为这是一个无参数的方法，所以只需要传null即可。
获取父类相关信息
如何获取父类的相关信息，可以使用getSuperclass()方法获取父类，当然也可以获取父类的方法，执行父类的方法。
Animal.java:
package FleshTest.Test;
public class Animal {
public void doSomething() {
System.out.println("animal do something");
}
}
Dog.java继承于Animal.java：
package FleshTest.Test;
public class Dog extends Animal{
public void doSomething(){
System.out.println("Dog do something");
}
}
测试代码：
package FleshTest.Test;
import java.lang.reflect.Method;
public class TestClass {
public static void main(String[] args) throws Exception {
Class<?> dogClass = Class.forName("FleshTest.Test.Dog");
System.out.println(dogClass);
invoke(dogClass);
Class<?> animalClass = dogClass.getSuperclass();
System.out.println(animalClass);
invoke(animalClass);
Class<?> objectClass = animalClass.getSuperclass();
System.out.println(objectClass);
invoke(objectClass);
}
public static void invoke(Class<?> myClass) throws Exception {
Method[] methods = myClass.getMethods();
// 遍历接口的方法
for (Method method : methods) {
if (method.getName().equalsIgnoreCase("doSomething")) {
// 通过反射调用方法
method.invoke(myClass.newInstance(), null);
}
}
}
}
结果：
获取当前类的公有属性和私有属性以及更新
使用getFields()可以获取到public的属性，包括static属性，使用getDeclaredFields()可以获取所有声明的属性，不管是public，protected,private不同修饰的属性。
修改public属性,只需要field.set(object，value)即可，但是private属性不能直接set，private默认是不允许外界操作其值的，这里我们可以使用field.setAccessible(true)；相当于打开了操作的权限。
static的属性修改和非static的一样，但是我们怎么获取呢？如果是public修饰的，可以直接用类名获取到，如果是private修饰的，那么需要使用filed.get(object)，这个方法其实对上面说的所有的属性都可以的。
实例代码：
package FleshTest;
import java.lang.reflect.Field;
class Person {
public static String type ;
private static String subType ;
// 名字（公有）
public String name;
protected String gender;
private String address;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}
public class TestPerson {
public static void main(String[] args) throws Exception{
Class<?> personClass = Class.forName("FleshTest.Person");
Field[] fields = personClass.getFields();
// 获取公开的属性
for(Field field:fields){
System.out.println(field);
}
System.out.println("=================");
// 获取所有声明的属性
Field[] declaredFields = personClass.getDeclaredFields();
for(Field field:declaredFields){
System.out.println(field);
}
System.out.println("=================");
Person person = (Person) personClass.newInstance();
person.name = "Sam";
System.out.println(person);
// 修改public属性
Field fieldName = personClass.getDeclaredField("name");
fieldName.set(person,"Jone");
// 修改private属性
Field addressName = personClass.getDeclaredField("address");
// 需要修改权限
addressName.setAccessible(true);
addressName.set(person,"东风路47号");
System.out.println(person);
// 修改static 静态public属性
Field typeName = personClass.getDeclaredField("type");
typeName.set(person,"人类");
System.out.println(Person.type);
// 修改静态 private属性
Field subType = personClass.getDeclaredField("subType");
subType.setAccessible(true);
subType.set(person,"黄种人");
System.out.println(subType.get(person));
}
}
结果： 从结果可以看出，不管是public，还是protected，private修饰的，我们都可以通过反射对其进行查询和修改，不管是静态变量还是非静态变量。getDeclaredField()可以获取到所有声明的属性，而getFields()则只能获取到public的属性。对于非public的属性，我们需要修改其权限才能访问和修改：field.setAccessible(true)。获取属性值需要使用field.get(object)，值得注意的是：每个属性，其本身就是对象
获取以及调用类的公有/私有方法
既然上文中提到可以获取到公有和私有的方法，那是否可以通过反射执行公有或者是私有的方法呢？
创建People类：
package FleshTest;
class People{
// 非静态公有无参数
public void read(){
System.out.println("reading...");
}
// 非静态公有无参数有返回
public String getName(){
return "Sam";
}
// 非静态公有带参数
public int readABookPercent(String name){
System.out.println("read "+name);
return 80;
}
// 私有有返回值
private String getAddress(){
return "东方路";
}
// 公有静态无参数无返回值
public static void staticMethod(){
System.out.println("static public method");
}
// 公有静态有参数
public static void staticMethodWithArgs(String args){
System.out.println("static public method:"+args);
}
// 私有静态方法
private static void staticPrivateMethod(){
System.out.println("static private method");
}
}
获取People类里面的方法：
public static void GetAllMethods() throws Exception {
Class<?> personClass = Class.forName("FleshTest.Person");
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("=============================================");
Method[] declaredMethods = personClass.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
}
}
结果： 我们发现getMethods()确实可以获取所有的公有的方法，但是有一个问题，就是他会把父类的也获取到，也就是下面图片后色框里面的，我们知道所有的类默认都继承了Object类，所以它把Object的那些方法都获取到了。而getDeclaredMethods确实可以获取到公有和私有的方法，不管是静态还是非静态，但是它是获取不到父类的方法的。
首先试一下调用非静态方法：
public static void getNoStatic() throws Exception {
Class<?> personClass = Class.forName("FleshTest.People");
People people = (People) personClass.newInstance();
Method[] declaredMethods = personClass.getDeclaredMethods();
for (Method method : declaredMethods) {
if(method.getName().equalsIgnoreCase("read")){
method.invoke(people,null);
System.out.println("===================");
}else if(method.getName().equalsIgnoreCase("getName")){
System.out.println(method.invoke(people,null));
System.out.println("===================");
}else if(method.getName().equalsIgnoreCase("readABookPercent")){
System.out.println(method.invoke(people,"随风飘的云"));
System.out.println("===================");
}
}
}
结果：
那如果调用私有方法呢？
public static void getNoPublic() throws Exception {
Class<?> personClass = Class.forName("FleshTest.People");
People people = (People) personClass.newInstance();
Method[] declaredMethods = personClass.getDeclaredMethods();
for (Method method : declaredMethods) {
if(method.getName().equalsIgnoreCase("getAddress")){
System.out.println(method.invoke(people, null));
}
}
}
结果： 这是因为不具有访问权限导致的。
修改代码添加允许访问权限的代码语句：
public static void getNoPublic() throws Exception {
Class<?> personClass = Class.forName("FleshTest.People");
People people = (People) personClass.newInstance();
Method[] declaredMethods = personClass.getDeclaredMethods();
for (Method method : declaredMethods) {
if(method.getName().equalsIgnoreCase("getAddress")){
// 添加这行语句
method.setAccessible(true);
System.out.println(method.invoke(people, null));
}
}
}
结果：
最后，如果想要调用静态方法或者是静态私有方法，那该怎么办呢？
public static void getStaticMethod() throws Exception {
Class<?> peopleClass = Class.forName("FleshTest.People");
People people = (People) peopleClass.newInstance();
Method[] declaredMethods = peopleClass.getDeclaredMethods();
for (Method method : declaredMethods) {
if(method.getName().equalsIgnoreCase("staticMethod")){
System.out.println("===================");
}else if(method.getName().equalsIgnoreCase("staticMethodWithArgs")){
System.out.println(method.invoke(people,"随风飘的云"));
System.out.println("===================");
}else if(method.getName().equalsIgnoreCase("staticPrivateMethod")){
// 设置方法允许访问
method.setAccessible(true);
System.out.println(method.invoke(people,null));
System.out.println("===================");
}
}
}
结果：
那如果不想使用遍历的方法调用这些方法，那该怎么办呢？
public static void getNoFor() throws Exception {
Class<?> peopleClass = Class.forName("FleshTest.People");
People people = (People) peopleClass.newInstance();
Method method1 = peopleClass.getMethod("readABookPercent", String.class);
method1.invoke(people, "唐诗三百首");
Method method2 = peopleClass.getMethod("getName", null);
System.out.println(method2.invoke(people, null));
}
结果：
文章参考
- （微信公众号）秦怀杂货店 ，作者Aphysia
- https://www.codercto.com/a/46094.html
- https://blog.csdn.net/sinat_38259539/article/details/71799078
- https://blog.csdn.net/qq_40896997/article/details/94483820
- https://www.cnblogs.com/zhaoguhong/p/6937364.html
- https://juejin.im/post/5c160420e51d452a60684431
- https://blog.csdn.net/mcryeasy/java/article/details/52344729
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
