Java09：反射（知识点+代码案例）

最新推荐文章于 2024-09-14 18:46:05 发布

阿隆兄

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量177

点赞数

分类专栏：摸爬滚打：向着offer前进文章标签： java

本文链接：https://blog.csdn.net/qq_41978688/article/details/113813896

版权

摸爬滚打：向着offer前进专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的类加载过程，包括类加载、连接、初始化的步骤及触发时机，强调了类加载器的作用和JVM的类加载机制。接着深入探讨了反射的概念，展示了获取Class对象的三种方式，以及如何通过反射获取和使用构造方法、成员变量和成员方法。最后，通过实际案例展示了反射在创建对象、调用方法、绕过泛型检查以及运行配置文件指定方法的应用。

摘要由CSDN通过智能技术生成

文章目录

反射

反射

1. 类加载器

1.1 类加载

1.1.1 类加载的描述

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

1.1.2 类的加载

就是指将class文件读入内存，并为之创建一个 java.lang.Class 对象
任何类被使用时，系统都会为之建立一个 java.lang.Class 对象

1.1.3 类的连接

验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
准备阶段：负责为类的类变量分配内存，并设置默认初始化值
解析阶段：将类的二进制数据中的符号引用替换为直接引用

1.1.4 类的初始化

在该阶段，主要就是对类变量进行初始化

1.1.5 类的初始化步骤

假如类还未被加载和连接，则程序先加载并连接该类
假如该类的直接父类还未被初始化，则先初始化其直接父类
假如类中有初始化语句，则系统依次执行这些初始化语句
注意：在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3

1.1.6 类的初始化时机

创建类的实例
调用类的类方法（静态方法）
访问类或者接口的类变量，或者为该类变量赋值
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

1.2类加载器【理解】

1.2.1 类加载器的作用

负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。虽然我们不用过分关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行！

1.2.2 JVM的类加载机制

全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区

1.2.3 Java中的内置类加载器

-ClassLoader 是负责加载类的对象

Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null ，并且没有父null
Platform class loader：平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类
System class loader：它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类
类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap

1.2.4 ClassLoader 中的两个方法

方法分类

方法名说明
static ClassLoader getSystemClassLoader() 返回用于委派的系统类加载器
ClassLoader getParent() 返回父类加载器进行委派

方法名	说明
static ClassLoader getSystemClassLoader()	返回用于委派的系统类加载器
ClassLoader getParent()	返回父类加载器进行委派

示例代码

public class ClassLoaderDemo {
    public static void main(String[] args) {
        //static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器
        ClassLoader c = ClassLoader.getSystemClassLoader();//ctrl alt v生成左边的内容 
        System.out.println(c); //AppClassLoader

        //ClassLoader getParent()：返回父类加载器进行委派
        ClassLoader c2 = c.getParent();
        System.out.println(c2); //PlatformClassLoader

        ClassLoader c3 = c2.getParent();
        System.out.println(c3); //null
    }
}

2. 反射

2.1反射的概述

一个类，通过类加载器加载对应的.class文件，解析成class，其中包含成员变量，成员方法，构造方法。通过class来使用成员变量，成员方法，构造方法称之为反射。
是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展
我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码；框架设计的灵魂是反射
反射：将类的各个组成部分封装为其他对象，这就是反射机制
* 好处：
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性。

2.2获取Class类对象的三种方式

2.2.1三种方式分类

三种方法分别对应着Java代码运行的三个阶段
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
类名.class属性

a. 使用类的class属性来获取对应的Class对象。举例：Student.class 将会返回Student对应的Class对象
b. 多用于参数的传递

对象名.getClass()方法

a. 调用对象的getClass()方法，返回该对象所属类对象的Class对象，该方法是Object类中的方法，所以Java对象都可以调用该方法
b. 多用于对象的获取字节码的方式

Class.forName(全类名)方法

a. 将字节码文件加载进内存，返回Class对象

b. 使用Class类的静态方法forName(String className),该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径.

c. 多用于配置文件，将类名定义在配置文件中。读取文件，加载类

2.2.2示例代码

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共
    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 address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法：一个私有，四个公共
    private void function() {
        System.out.println("function");
    }

    public void method1() {
        System.out.println("method");
    }

    public void method2(String s) {
        System.out.println("method:" + s);
    }

    public String method3(String s, int i) {
        return s + "," + i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

/*
    三种方式获取Class对象
        1:使用类的class属性来获取该类对应的Class对象。举例：Student.class将会返回Student类对应的Class对象
        2:调用对象的getClass()方法，返回该对象所属类对应的Class对象
            该方法是Object类中的方法，所有的Java对象都可以调用该方法
        3:使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象，最方便
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------");

        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------");

        //使用Class类中的静态方法forName(String className)  灵活性最好
        Class<?> c4 = Class.forName("com.itheima_02.Student");//泛型
        System.out.println(c1 == c4);
    }
}

2.3 反射获取构造方法并使用[Constructor]

2.3.1 Class类获取构造方法对象的方法

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor getConstructor(Class<?>… parameterTypes)	返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造方法对象

2.3.2 Constructor类用于创建对象的方法

方法名	说明
T newInstance(Object…initargs)	根据指定的构造方法创建对象

示例代码

/*
    反射获取构造方法并使用
 */
public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo02.Student");

//      需求01：得到公共的构造方法
        //Constructor<?>[] getConstructors()
        // 返回一个包含 Constructor对象的数组， Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
//        Constructor<?>[] cons = c.getConstructors();//只能得到公共的构造方法，不能得到私有的，和默认的

//      需求02：得到所有的构造方法
        //Constructor<?>[] getDeclaredConstructors()
        // 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("--------");

//      需求03：得到一个指定的构造方法
        //Constructor<T> getConstructor(Class<?>... parameterTypes)
        // 返回一个 Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象

        Constructor<?> con = c.getConstructor();

        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
 //     需求04：通过反射里面的构造方法来创建对象
        Object obj = con.newInstance();
        System.out.println(obj);//ToString方法

        //     下面代码是普通创建对象，不是通过反射来创建对象
//        Student s = new Student();
//        System.out.println(s);
    }
}

2.3.3 反射获取构造方法并使用练习1

案例需求
- 通过反射获取公共的构造方法并创建对象
代码实现
- 学生类

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共
    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 address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法：一个私有，四个公共
    private void function() {
        System.out.println("function");
    }

    public void method1() {
        System.out.println("method");
    }

    public void method2(String s) {
        System.out.println("method:" + s);
    }

    public String method3(String s, int i) {
        return s + "," + i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

测试类

/*
    通过反射实现如下的操作：
        Student s = new Student("林青霞",30,"西安");
        System.out.println(s);
 */
public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo01.Student");//包名+类

        //public Student(String name, int age, String address) 获取带三个参数的构造方法
        //Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getConstructor(String.class, int.class, String.class);
        //基本数据类型也可以通过.class得到对应的Class类型

        //T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 30, "西安");
        System.out.println(obj);
    }
}

2.3.4 反射获取构造方法并使用练习2

案例需求
- 通过反射获取私有构造方法并创建对象
代码实现
- 学生类：参见上方学生类
- 测试类

/*
    通过反射实现如下的操作：
        Student s = new Student("林青霞");
        System.out.println(s);
 */
public class ReflectDemo03 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo01.Student");//ctrl alt v

        //private Student(String name)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getDeclaredConstructor(String.class);

        //私有的构造方法，不能直接使用，但是利用反射可以
        //暴力反射
        //public void setAccessible(boolean flag):值为true，取消访问检查
        con.setAccessible(true);

        Object obj = con.newInstance("林青霞");
        System.out.println(obj);

    }
}

2.4 反射获取成员变量并使用[Field]

2.4.1 Class类获取成员变量对象的方法

方法分类

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

2.4.2 Field类用于给成员变量赋值的方法

方法名	说明
voidset(Object obj,Object value)	给obj对象的成员变量赋值为value

2.4.3 示例代码

/*
    反射获取成员变量并使用
 */
public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo02.Student");

        //Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段【只能是公共】

        //Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段（包括私有、默认）

//        Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for(Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");

    //需求：利用反射给成员变量赋值
        //        Student s = new Student();
//        s.address = "西安";
//        System.out.println(s);


        //Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段【只能是公共】
        //Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定声明字段
        Field addressField = c.getField("address");

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //Field提供有关类或接口的单个字段的信息和动态访问
        //void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
        addressField.set(obj,"西安"); //给obj的成员变量addressField赋值为西安

        System.out.println(obj);
        
    }
}

2.4.4 反射获取成员变量并使用练习

案例需求
- 通过反射获取成员变量并赋值
代码实现
- 学生类：参见上方学生类
- 测试类

/*
    练习：通过反射实现如下操作
        Student s = new Student();
        s.name = "林青霞";
        s.age = 30;
        s.address = "西安";
        System.out.println(s);
 */
public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo02.Student");

        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);

        //s.name = "林青霞";
//        Field nameField = c.getField("name"); //NoSuchFieldException: name
        Field nameField = c.getDeclaredField("name");//万能的
        nameField.setAccessible(true);//因为name是私有。万能的
        nameField.set(obj, "林青霞");
        System.out.println(obj);

        //s.age = 30;
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,30);
        System.out.println(obj);

        //s.address = "西安";
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true);//公共的成员变量，可不写该语句，但写了不会报错
        addressField.set(obj,"西安");
        System.out.println(obj);
    }
}

2.5 反射获取成员方法并使用[Method]

2.5.1 Class类获取成员方法对象的方法

方法分类

方法名	说明
Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>… parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>… parameterTypes)	返回单个成员方法对象

2.5.2 Method类用于执行方法的方法

方法名	说明
Objectinvoke(Object obj,Object… args)	调用obj对象的成员方法，参数是args,返回值是Object类型

2.5.3 示例代码

/*
    反射获取成员方法并使用
 */
public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");

        //Method[] getMethods()
// 返回一个包含 方法对象的数组， 方法对象反映由该 Class对象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类

        //Method[] getDeclaredMethods()
// 返回一个包含 方法对象的数组， 方法对象反映由 Class对象表示的类或接口的所有声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承方法

//        Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();

        for(Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------");

//需求：用反射的方法创建对象并调用method1方法
        //        Student s = new Student();
//        s.method1();


        //Method getMethod(String name, Class<?>... parameterTypes)
        // 返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法
        //Method getDeclaredMethod(String name, Class<?>... parameterTypes)
        // 返回一个 方法对象，它反映此表示的类或接口的指定声明的方法 Class对象

        //public void method1()
        Method m = c.getMethod("method1");

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

//        obj.m();  错误写法

        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此 方法对象表示的基础方法
        //Object：返回值类型
        //obj：调用方法的对象
        //args：方法需要的参数
        m.invoke(obj);

    }
}

2.5.4 反射获取成员方法并使用练习

案例需求
- 通过反射获取成员方法并调用
代码实现
- 学生类：参见上方学生类
- 测试类

/*
     练习：通过反射实现如下操作
        Student s = new Student();
        s.method1();
        s.method2("林青霞");
        String ss = s.method3("林青霞",30);
        System.out.println(ss);
        s.function();
 */
public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.demo02.Student");

        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //需求01：s.method1();  无参方法
        Method m1 = c.getMethod("method1");
        m1.invoke(obj);

        //需求02：s.method2("林青霞");  带参方法
        Method m2 = c.getMethod("method2", String.class);
        m2.invoke(obj,"林青霞");

//        需求03： String ss = s.method3("林青霞",30);   带多个参数并且有返回值的方法
//        System.out.println(ss);
        Method m3 = c.getMethod("method3", String.class, int.class);
        Object o = m3.invoke(obj, "林青霞", 30);
        System.out.println(o);

        //需求04： s.function(); function   私有方法
//        Method m4 = c.getMethod("function"); //NoSuchMethodException: com.itheima_02.Student.function()
        //若不知道方法是公共的还是私有的，就用万能的getDeclaredMethod方法+setAccessible(true);

        Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

2.6 获取全类名

String getName()

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("D202101.D0113.Student");
        String name = aClass.getName();
        System.out.println(name);//D202101.D0113.Student
    }

}

2.7 反射的案例

2.7.1反射练习之越过泛型检查

案例需求
- 通过反射技术，向一个泛型为Integer的ArrayList集合中添加一些字符串数据
代码实现

/*
    练习1：我有一个ArrayList<Integer>集合，现在我想在这个集合中添加一个字符串数据，如何实现？
 */
public class ReflectTest01 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //创建集合
        ArrayList<Integer> array = new ArrayList<Integer>();

//        array.add(10);
//        array.add(20);
//        array.add("hello"); 报错了

        Class<? extends ArrayList> c = array.getClass();
        //反射可以跳过泛型检查，获取原始的方法类型
        Method m = c.getMethod("add", Object.class);

        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");

        System.out.println(array);
    }
}

2.7.2 运行配置文件中指定类的指定方法

案例需求
- 通过反射运行配置文件中指定类的指定方法
代码实现
首先先在模块目录下新建class.txt 文件

className=com.project.Teacher
methodName=teach

public class Teacher {
    public void teach() {
        System.out.println("用爱成就学员");
    }
}

public class Student {
    public void study() {
        System.out.println("好好学习天天向上");
    }
}

/*
    练习2：通过配置文件运行类中的方法
    反射的灵活性
 */
public class ReflectTest02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        Student s = new Student();
//        s.study();

//        Teacher t = new Teacher();
//        t.teach();

        /*
            class.txt
            className=xxx
            methodName=xxx
         */

        //加载得到数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("myReflect\\class.txt");
        prop.load(fr);
        fr.close();

        /*
            className=com.itheima_06.Student
            methodName=study
         */

        //通过键得到值
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射来使用
        Class<?> c = Class.forName(className);//com.project.Student

        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getMethod(methodName);//study
        m.invoke(obj);
    }
}