Java 反射相关的面试题

Java 创建对象有几种方式？

1. new 创建新对象

2. 通过反射创建对象

3. 采用 clone 机制

4. 通过序列化机制

使用 new 关键字

public class MyClass {
    public MyClass() {
        System.out.println("MyClass object created!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
    }
}

使用反射

通过 Class 对象的 newInstance 方法或通过构造器对象创建实例。

public class MyClass {
    public MyClass() {
        System.out.println("MyClass object created using reflection!");
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            // 使用 Class.forName 获取类对象
            Class<?> clazz = Class.forName("MyClass");
            // 创建实例
            MyClass obj = (MyClass) clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用 clone 方法

通过实现 Cloneable 接口和覆盖 clone 方法来创建对象的副本。

public class MyClass implements Cloneable {
    public MyClass() {
        System.out.println("MyClass object created!");
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            MyClass obj1 = new MyClass();
            MyClass obj2 = (MyClass) obj1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

使用序列化和反序列化

通过将对象序列化到字节流，然后从字节流反序列化回对象。

import java.io.*;

public class MyClass implements Serializable {
    public MyClass() {
        System.out.println("MyClass object created!");
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            // 序列化对象到文件
            MyClass obj1 = new MyClass();
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            oos.writeObject(obj1);
            oos.close();

            // 从文件反序列化对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
            MyClass obj2 = (MyClass) ois.readObject();
            ois.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Java 反射的作用与原理

1、定义

反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。在 Java 中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。

这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

2、哪里会用到反射机制？

反射机制在许多 Java 应用中都有广泛的使用，主要包括以下几种场景：

Spring 框架

Spring 使用反射进行依赖注入（DI）和面向切面编程（AOP）。例如，通过反射来创建和注入 @Autowired 注解标记的依赖。

@Component
public class MyService {
    @Autowired
    private MyRepository myRepository;
}

在运行时，Spring 使用反射扫描注解并注入依赖。

动态代理

反射在创建动态代理对象时起到关键作用，特别是在 AOP 和拦截器的实现中。

JDK 动态代理

通过反射创建动态代理对象来拦截方法调用。

InvocationHandler handler = new MyInvocationHandler();
MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
    MyInterface.class.getClassLoader(),
    new Class<?>[]{MyInterface.class},
    handler
);

序列化和反序列化

反射用于序列化和反序列化对象，例如在 JSON 和 XML 解析中。

Jackson 和 Gson

这些库使用反射将 Java 对象转换为 JSON 字符串，或将 JSON 字符串转换为 Java 对象。

ObjectMapper objectMapper = new ObjectMapper();
String jsonString = objectMapper.writeValueAsString(myObject);
MyObject obj = objectMapper.readValue(jsonString, MyObject.class);

测试框架

反射在测试框架中被广泛使用，以便在运行时动态发现和调用测试方法。

JUnit

JUnit 使用反射查找和执行标注了 @Test 的方法。

public class MyTests {
    @Test
    public void testMethod() {
        // Test logic
    }
}

代码生成和分析工具

反射用于生成和分析 Java 代码。例如，通过注解处理器生成代码或通过反射获取类的元数据。

Lombok

Lombok 使用注解处理器和反射生成 getter、setter、构造函数等代码。

@Data
public class MyClass {
    private String name;
}

配置驱动开发

反射用于根据配置文件动态加载和配置类。例如，读取 XML 或 JSON 配置文件，动态加载相应的类并设置其属性。

public class ConfigLoader {
    public Object loadConfig(String className, Map<String, String> properties) throws Exception {
        Class<?> clazz = Class.forName(className);
        Object obj = clazz.getDeclaredConstructor().newInstance();
        for (Map.Entry<String, String> entry : properties.entrySet()) {
            Field field = clazz.getDeclaredField(entry.getKey());
            field.setAccessible(true);
            field.set(obj, entry.getValue());
        }
        return obj;
    }
}

3、反射的实现方式

第一步：获取 Class 对象，有 4 种方法

1、Class.forName("类的路径");
2、类名.class
3、对象.getClass()
4、基本类型的包装类，可以调用包装类的 Type 属性来获得该包装类的 Class 对象

4、实现 Java 反射的类

Java 反射机制是通过一组类和接口来实现的，这些类和接口主要位于 java.lang.reflect 包中。以下是一些实现 Java 反射的关键类和接口，以及它们的主要功能：

1. Class：表示正在运行的 Java 应用程序中的类和接口

注意：所有获取对象的信息都需要 Class 类来实现

2. Field：提供有关类和接口的属性信息，以及对它的动态访问权限
3. Constructor：提供关于类的单个构造方法的信息以及它的访问权限
4. Method：提供类或接口中某个方法的信息

Class 类

Class 类是反射机制的核心类，表示正在运行的 Java 应用程序中的类和接口。

// 获取类的 Class 对象
Class<?> clazz = MyClass.class;

// 通过 Class 对象创建实例
MyClass instance = (MyClass) clazz.getDeclaredConstructor().newInstance();

Method 类

Method 类表示类或接口的方法，可以用来获取方法的信息和调用方法。

// 获取方法对象
Method method = clazz.getDeclaredMethod("myMethod", String.class);

// 调用方法
method.invoke(instance, "Hello, World!");

Field 类

Field 类表示类或接口的字段，可以用来获取字段的信息和设置字段的值。

// 获取字段对象
Field field = clazz.getDeclaredField("myField");

// 设置字段可访问
field.setAccessible(true);

// 获取字段值
Object value = field.get(instance);

// 设置字段值
field.set(instance, "New Value");

Constructor 类

Constructor 类表示类的构造函数，可以用来获取构造函数的信息和创建实例。

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

// 创建实例
MyClass anotherInstance = (MyClass) constructor.newInstance("Constructor Argument");

Modifier 类

Modifier 类提供了一些静态方法和常量，用于解析类和成员的访问修饰符。

// 获取方法的修饰符
int modifiers = method.getModifiers();
boolean isPublic = Modifier.isPublic(modifiers);

Array 类

Array 类提供了静态方法来动态创建和操作数组。

// 创建数组
Object array = Array.newInstance(String.class, 5);

// 设置数组元素
Array.set(array, 0, "Hello");
String value = (String) Array.get(array, 0);

Annotation 接口

Annotation 接口表示注解，反射可以用于获取类、方法、字段上的注解信息。

// 获取类上的注解
Annotation[] annotations = clazz.getAnnotations();

// 获取方法上的注解
Annotation[] methodAnnotations = method.getAnnotations();

5、反射机制的优缺点

优点：

1）能够运行时动态获取类的实例，提高灵活性

2）与动态编译结合

缺点：

1）使用反射性能较低，需要解析字节码，将内存中的对象进行解析

2）相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）