反射基础

首先来看一下最常规的创建对象的方式:

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 对应的 ClassClass<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;}@Overridepublic 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{@Overridepublic void Is_Alive() {System.out.println("猫是活的");}@Overridepublic 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;@Overridepublic 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

java反射机制详解篇一（基础）相关推荐

java 反射机制详解
火星十一郎海纳百川, 有容乃大,QQ:791909235,Tel:13137910179 posts - 774, comments - 556, trackbacks - 0, articles ...
java反射机制详解_Java反射机制详解
Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反 ...
[转]Java反射机制详解
目录 1反射机制是什么 2反射机制能做什么 3反射机制的相关API ·通过一个对象获得完整的包名和类名 ·实例化Class类对象 ·获取一个对象的父类与实现的接口 ·获取某个类中的全部构造函数 - 详 ...
java反射机制详解_JAVA反射机制详解_JSP/Java编程_互联网开发技术网_传播最新的编程技术_php361.com...
今天,下午在和朋友聊天的时候,聊起了反射这个话题. 我们就从下面这个段简单的代码开始吧. 这个代码输出什么,想必大部分的读者跟我一样,会很快地知道答案:0 1 2 3 4 5 6 7 8 9.事实也是 ...
Java反射机制详解
文章目录 1.反射 1.1 反射的概述为什么需要反射? 1.2 获取Class类对象的三种方式 1.2.1 代码示例 1.3 反射获取构造方法并应用 1.3.1 Class类获取构造方法对象的方法 ...
java 反射机制详解_java反射机制原理详解
反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力.通过这种能力可以彻底的了解自身的情况为下一步的动作做准备.下面具体介绍一下java的反射机制.这里你将颠覆原来对java的理解. J ...
Java 反射机制详解：私有方法调用头大？如何通过反射调用类中的私有方法？
文章目录前言一.私有方法在本类中直接调用 1.1.在本类中实例化,调用私有方法 1.2.尝试在其他类直接调用私有方法(错误示范) 二.使用反射实例化类强制调用私有方法 2.1.使用类加载器加载被调 ...
【Java反射机制详解】—— 每天一点小知识
反射数据类型_Java基础：反射机制详解
一.什么是反射: (1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法.本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取t对 ...

java反射机制详解篇一（基础）

反射基础

Class类详解

类加载

类的加载器

类的加载机制

反射的使用场景

获取对象的包名以及类名

Class类对象的获取

获取指定类型的实例化对象

构造函数对象实例化对象

获取类继承的接口

获取父类相关信息

获取当前类的公有属性和私有属性以及更新

获取以及调用类的公有/私有方法

文章参考

java反射机制详解篇一（基础）相关推荐

最新文章

热门文章