详细分析Java中的反射与new创建对象（附Demo）

前言

对于Java的基本知识推荐阅读：

1. java框架 零基础从入门到精通的学习路线 附开源项目面经等（超全）
2. 【Java项目】实战CRUD的功能整理（持续更新）

1. 基本知识

Java中的反射（Reflection）和使用new关键字创建对象是两种不同的对象创建方式，各有优缺点和适用场景

第一：使用new关键字创建对象

优点

• 编译时类型检查：在编译时就可以检查类型是否正确
• 性能高：不涉及额外的解析和方法调用，直接创建对象

缺点

• 灵活性差：不能在运行时动态决定要创建的对象类型

基本的测试代码如下：

public class Main {
    public static void main(String[] args) {
        // 使用new关键字创建对象
        MyClass obj = new MyClass();
        obj.sayHello();
    }
}

class MyClass {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

二、使用反射创建对象

优点

• 灵活性高：可以在运行时动态决定要创建的对象类型，适用于框架和工具类

缺点

• 性能较低：由于需要解析类名和方法名，性能比直接使用new关键字低
• 缺乏编译时类型检查：可能会在运行时抛出异常

示例代码如下：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Main {
    public static void main(String[] args) {
        try {
            // 使用反射创建对象
            Class<?> clazz = Class.forName("MyClass");
            Constructor<?> constructor = clazz.getConstructor();
            MyClass obj = (MyClass) constructor.newInstance();
            obj.sayHello();
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

简单分析其效率对比 以及 使用的场景

方面	使用new关键字	使用反射
创建对象的效率	高效：编译后生成的字节码直接创建对象，无需额外解析和方法调用	较低：需要解析类名和方法名、获取构造器等操作，额外增加了开销
方法调用的效率	高效：直接调用对象方法，无额外开销	较低：需通过反射API调用方法，效率较低
使用场景	确定的场景下，直接创建对象，例如日常开发中的大部分情况	需要在运行时动态决定要创建的对象类型，例如框架开发（如Spring框架中的依赖注入）、工具类开发（如ORM框架）

2. 效率对比

public class PerformanceTest {
    public static void main(String[] args) {
        final int iterations = 1000000;

        // 测试new关键字
        long startNew = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            MyClass obj = new MyClass();
        }
        long endNew = System.nanoTime();
        System.out.println("Using new keyword: " + (endNew - startNew) + " ns");

        // 测试反射
        long startReflection = System.nanoTime();
        try {
            for (int i = 0; i < iterations; i++) {
                Class<?> clazz = Class.forName("MyClass");
                Constructor<?> constructor = clazz.getConstructor();
                MyClass obj = (MyClass) constructor.newInstance();
            }
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        long endReflection = System.nanoTime();
        System.out.println("Using reflection: " + (endReflection - startReflection) + " ns");
    }
}

class MyClass {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

截图如下：

具体时间因机器性能和JVM状态不同而异

3. 反射补充知识

反射创建对象的三种主要方式是通过类字面常量、Class.forName()方法和对象实例的getClass()方法

3.1 类字面场量

在编译时就知道类的类型，适用于类名已知且在同一编译单元中的情况

public class ReflectDemo {
    public void sayHello() {
        System.out.println("Hello, World!");
    }

    public static void main(String[] args) {
        // 方式1：使用类字面常量
        Class<ReflectDemo> reflectDemoClass = ReflectDemo.class;
        try {
            ReflectDemo reflectDemo = reflectDemoClass.newInstance();
            reflectDemo.sayHello();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

3.2 Class.forName()

适用于类名在运行时才知道的情况，常用于从配置文件或输入中读取类名，然后动态加载类

public class ReflectDemo {
    public void sayHello() {
        System.out.println("Hello, World!");
    }

    public static void main(String[] args) {
        try {
            // 方式2：使用Class.forName()
            Class<?> reflectDemoClass = Class.forName("ReflectDemo");
            ReflectDemo reflectDemo = (ReflectDemo) reflectDemoClass.newInstance();
            reflectDemo.sayHello();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

3.3 对象实例的 getClass()

适用于已有实例对象时，通过该对象获取其类信息，然后创建新的实例

public class ReflectDemo {
    public void sayHello() {
        System.out.println("Hello, World!");
    }

    public static void main(String[] args) {
        ReflectDemo existingInstance = new ReflectDemo();
        // 方式3：使用对象实例的getClass()
        Class<? extends ReflectDemo> reflectDemoClass = existingInstance.getClass();
        try {
            ReflectDemo newReflectDemo = reflectDemoClass.newInstance();
            newReflectDemo.sayHello();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

3.4 总结

方式	优点	缺点
使用类字面常量 (ClassName.class)	- 编译时类型安全 - 性能最佳	- 类名在编译时必须已知 - 灵活性较差
使用 Class.forName()	- 可以在运行时根据类名动态加载类 - 灵活性高	- 类名必须为字符串形式 - 可能会引发ClassNotFoundException - 性能略低于类字面常量
使用对象实例的 getClass()	- 可以通过已有实例获取类信息 - 动态创建相同类型的新实例	- 需要先有一个实例对象 - 性能略低于类字面常量，但高于Class.forName()