Java笔记 —— 反射（概念，方法，实例

（1）验证：对文件格式等内部结构是否正确

（2）准备：为类变量分配内存并设置初始值

（3）解析：将类的二进制数据中的符号引用替换为直接引用

3. 初始化：到这一步开始执行类里面自己编写的代码，完成类的初始化

类加载器：负责将.class文件加载到内存中，并为之生成对应的Class对象。

反射的定义

加载完类之后产生的这个Class类型的对象（一个类只会有一个Class对象），会包含这个类的完整信息（包括类名，父类，接口，这个类的所有方法，变量等），我们通过这个Class对象看到这个对象对应的类的所有信息。这个对象就可以比喻成一面镜子，透过这面镜子看到类的信息。

这种通过Class对象获得其对应的类的所有信息的行为称为反射。（这里又总结一遍反射的定义）

类似于public final class String，String类一样，String类有构造方法和成员方法。

public final class Class是反射的核心类，也同样有着一套自己的构造方法和成员方法

反射的功能（包括但不限于）：

1. 在运行时判断任意一个对象所属的类

2. 在运行时构造任意一个类的对象

3. 在运行时判断任意一个类所具有的成员变量和方法

4. 在运行时调用任意一个对象的成员变量和方法

像我之前说的例子，根据一个class文件对象去获得，使用这个class文件中成员方法，成员变量等，算是比较常用的功能之一。

获取Class类型对象

既然获取了一个class类的Class对象，就可以获得这个类的全部信息，那么我们该如何获得这个Class对象呢？

1. 通过Object中的getClass()方法获取，返回该Object的运行时类

2. 通过类名获取静态属性class

3. Class类中的静态方法 public static 类<?> forName(String className)（通常使用这个方法）

package test.reflexDemo;

public class Student {

private String name;

int age;

public String hobby;

public Student(){

}

private Student(String name){

this.name = name;

}

Student(String name,int age){

this.name = name;

this.age = age;

}

public Student(String name,int age,String hobby){

this.name = name;

this.age = age;

this.hobby = hobby;

}

public void test(){

System.out.println(“public修饰的无参的方法”);

}

public String show(String name,int age){

System.out.println(“public修饰的含参的方法”);

return name + “—” + age;

}

void function(String name){

System.out.println("默认修饰符的含参的方法，姓名是 "+name);

}

private void demo(String hobby){

System.out.println("private修饰的含参的方法，爱好是 "+hobby);

}

@Override

public String toString() {

return “Student{” +

“name='” + name + ‘’’ +

“, age=” + age +

“, hobby='” + hobby + ‘’’ +

‘}’;

}

}

这里的Student就相当于Class，这里的s就相当于Class类型对象

package test.reflexDemo;

public class Demo1 {

public static void main(String[] args) throws ClassNotFoundException {

//这里的Student就相当于Class，这里的s就相当于Class类型对象

Student s = new Student();

//方式一，getClass()方法,获得该对象的运行时类

Class<? extends Student> c1 = s.getClass();

Student s1 = new Student();

Class<? extends Student> c2 = s1.getClass();

System.out.println(c1==c2); // true

//这里结果为true的原因，同一个class可以new出来多个对象，但是只会对应一个Class类型对象

//所以c1和c2是一样的，但是s和s1是不一样的

System.out.println(s==s1); // false

System.out.println(“-----------------------------”);

//方式二，通过类名获得静态属性class

Class c3 = Student.class;

System.out.println(c3 == c1); //true

System.out.println(c3 == c2); //true

System.out.println(“-----------------------------”);

//方式三，利用Class类中的静态方法forName(String className)

//这个方法会返回给定字符串名称className的类或接口相关联的类对象，然后通过类对象调用类的方法和变量

//注意这里的className需要写类在项目中的具体位置

Class<?> c4 = Class.forName(“test.reflexDemo.Student”);

System.out.println(c4 == c3); //true

System.out.println(c4 == c2); //true

System.out.println(c4 == c1); //true

//Class后面的泛型可以不添加

//这样看起来更直接一些，c5是Class类型

Class c5 = Class.forName(“test.reflexDemo.Student”);

System.out.println(c5 == c4); //true

}

}

根据Class类型对象来创建类的实例

上面成功获得了Class类型对象，那么如何通过Class类型对象来创建对应的class类的对象呢？

思路是通过Class类型对象，来获得对应类的构造方法，然后再用构造方法来创建类的实例。

批量获取构造方法

package test.reflexDemo;

import java.lang.reflect.Constructor;

public class Demo2 {

public static void main(String[] args) throws ClassNotFoundException {

Class c = Class.forName(“test.reflexDemo.Student”);

//public Constructor<?>[] getConstructors()

// 返回文件中的所有public修饰的构造方法，不会获取private或者默认修饰的构造方法

Constructor[] constructors = c.getConstructors();

for (Constructor constructor : constructors) {

System.out.println(constructor);

}

System.out.println(“----------------------”);

//public Constructor<?>[] getDeclaredConstructors()

//返回所有的构造方法，包括private和默认修饰的构造方法

//另外这里获取的private修饰的构造方法也可以构建对象

Constructor[] dcs = c.getDeclaredConstructors();

for (Constructor d : dcs) {

System.out.println(d);

}

}

}

获取单个的构造方法

package test.reflexDemo;

import java.lang.reflect.Constructor;

public class Demo3 {

public static void main(String[] args) throws Exception {

Class c = Class.forName(“test.reflexDemo.Student”);

//public Constructor getConstructor(Class<?>… parameterTypes)

//括号里的参数是指具体数据类型对应的类，比如String要写成String.class

//什么都没写就是获取默认无参构造方法

Constructor cons1 = c.getConstructor();

System.out.println(“无参构造方法”+cons1);

Constructor cons2 = c.getConstructor(String.class,int.class,String.class);

System.out.println(“有参构造方法”+cons2);

//同样的，这样只能获得public类型,要想获得private类型需要改为

//getDeclaredConstructor

Constructor cons3 = c.getDeclaredConstructor(String.class);

System.out.println(“private修饰的有参构造方法”+cons3);

System.out.println(“--------------------------”);

//根据获得的构造方法创建实例

//public T newInstance(Object… initargs)

//括号里面写要传入构造方法中的参数

Object o1 = cons1.newInstance();

System.out.println(o1);

//这里可以向下转型

Student s = (Student)o1;

System.out.println(s);

//虽然获得了Private修饰的构造方法，但不能直接写入，会报权限不足的异常

//需要强行获取权限，暴力访问

cons3.setAccessible(true);

Object o2 = cons3.newInstance(“张”);

System.out.println(o2);

}

}

结果为

获取成员变量

批量获得成员变量

package test.reflexDemo;

import java.lang.reflect.Field;

public class Demo4 {

public static void main(String[] args) throws Exception{

Class c = Class.forName(“test.reflexDemo.Student”);

//获取所有的成员变量

//getFields()返回一个Field类型的数组，包含所有public修饰的成员变量

Field[] fields = c.getFields();

for (Field field : fields) {

System.out.println(field);

}

System.out.println(“--------------------”);

//getDeclaredFields()获取所有的成员变量，包括被private和默认修饰等类型修饰的变量

Field[] declaredFields = c.getDeclaredFields();

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

大厂面试真题：

(“test.reflexDemo.Student”);

//获取所有的成员变量

//getFields()返回一个Field类型的数组，包含所有public修饰的成员变量

Field[] fields = c.getFields();

for (Field field : fields) {

System.out.println(field);

}

System.out.println(“--------------------”);

//getDeclaredFields()获取所有的成员变量，包括被private和默认修饰等类型修饰的变量

Field[] declaredFields = c.getDeclaredFields();

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

[外链图片转存中…(img-yloMYPF7-1714384760498)]

大厂面试真题：

[外链图片转存中…(img-XL1NkO5n-1714384760499)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录