【面试干货】Class.forName()与ClassLoader.loadClass()在Java反射中的区别

news2024/12/23 6:28:30

【面试干货】Class.forName（）与ClassLoader.loadClass（）在Java反射中的区别

1、Class.forName()
- 1.1 示例代码
- 1.2 关键点
2、ClassLoader.loadClass()
- 2.1 示例代码
- 2.2 关键点
3、两者之间的区别

💖The Begin💖点点关注，收藏不迷路💖

在Java中，Class.forName()和ClassLoader.loadClass() 两个方法都被用于动态加载类，但它们在行为和使用场景上存在一些重要的区别。下面我们将详细探讨这两个方法的不同之处。

1、Class.forName()

Class.forName()方法 是Java中用来动态加载类并初始化它的常用方法。该方法接受一个字符串参数，该字符串参数指定了要加载的类的完全限定名（包括包名）。

1.1 示例代码

下面是一个更完整的示例代码，它展示了如何使用反射机制加载类并进行一些基本操作，如创建实例、调用方法和访问字段。

1、类com.example.MyClass

package com.example;

public class MyClass {
    private String message;

    public MyClass(String message) {
        this.message = message;
    }

    public void printMessage() {
        System.out.println("Message: " + message);
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

2、接下来是使用反射机制加载这个类并进行操作的完整示例代码：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 加载类
            Class<?> clazz = Class.forName("com.example.MyClass");

            // 获取构造函数
            Constructor<?> constructor = clazz.getConstructor(String.class);

            // 创建实例
            Object myObject = constructor.newInstance("Hello, Reflection!");

            // 获取方法
            Method printMethod = clazz.getMethod("printMessage");
            Method getMethod = clazz.getMethod("getMessage");
            Method setMethod = clazz.getMethod("setMessage", String.class);

            // 调用方法
            System.out.println("调用 printMessage 方法：");
            printMethod.invoke(myObject);

            // 获取字段
            Field messageField = clazz.getDeclaredField("message");

            // 修改字段的访问权限以便直接访问
            messageField.setAccessible(true);

            // 获取字段值
            String messageValue = (String) messageField.get(myObject);
            System.out.println("字段 'message' 的值: " + messageValue);

            // 设置字段值
            messageField.set(myObject, "New Message via Reflection");

            // 再次调用方法
            System.out.println("再次调用 printMessage 方法：");
            printMethod.invoke(myObject);

            // 使用getter和setter方法
            setMethod.invoke(myObject, "Another Message");
            String newMessageValue = (String) getMethod.invoke(myObject);
            System.out.println("通过 setter 更新后的消息: " + newMessageValue);

        } catch (ClassNotFoundException e) {
            System.out.println("找不到指定的类。");
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            System.out.println("找不到指定的方法。");
            e.printStackTrace();
        } catch (InstantiationException e) {
            System.out.println("无法实例化对象。");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.out.println("非法访问。");
            e.printStackTrace();
        } catch (java.lang.reflect.InvocationTargetException e) {
            System.out.println("方法调用异常。");
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            System.out.println("找不到指定的字段。");
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

1.2 关键点

1、初始化： Class.forName()方法默认会初始化类，即执行类的静态代码块和初始化静态变量。

2、异常处理： 如果找不到指定的类，会抛出ClassNotFoundException异常。

2、ClassLoader.loadClass()

ClassLoader.loadClass() 方法也是用来动态加载类的，但它不会初始化类。 这意味着它只加载类的字节码到JVM中，但不会执行任何静态代码块或初始化静态变量。

2.1 示例代码

1、类 com.example.MyClass

package com.example;

public class MyClass {
    public MyClass() {
        // 默认构造函数
        System.out.println("已创建MyClass实例。");
    }

    public void exampleMethod() {
        // 示例方法
        System.out.println("已调用exampleMethod方法。");
    }
}

2、使用了ClassLoader来加载类，并且在成功加载类之后进行了后续操作。如何通过反射调用类的方法或构造函数。

package com.example;

public class ClassLoaderExample {
    public static void main(String[] args) {
        // 获取当前线程的上下文类加载器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

        try {
            // 加载类com.example.MyClass
            Class<?> clazz = classLoader.loadClass("com.example.MyClass");

            // 输出类名，确认已经成功加载类
            System.out.println("已加载类：" + clazz.getName());

            // 创建实例（默认构造函数）
            Object instance = clazz.getDeclaredConstructor().newInstance();

            // 调用方法exampleMethod（假设该方法存在）
            java.lang.reflect.Method method = clazz.getMethod("exampleMethod");
            method.invoke(instance);

        } catch (ClassNotFoundException e) {
            System.err.println("未找到类：" + e.getMessage());
        } catch (NoSuchMethodException e) {
            System.err.println("未找到方法：" + e.getMessage());
        } catch (InstantiationException | IllegalAccessException | java.lang.reflect.InvocationTargetException e) {
            System.err.println("无法创建实例或调用方法：" + e.getMessage());
        }
    }
}