当前位置：首页 > article >正文

Java面试泛型相关知识点、面试题（含答案）

article 2024/10/26 22:38:53

！！！请各位准大厂员工一定不要杂乱无章的准备Java面试相关技术栈，详细最新最全面的技术栈思维导图，我已经为你准备好了：最新Java技术栈思维导图
Java 的泛型（Generics）是一种提供编译时类型检查的机制，允许在类、接口和方法中定义、传递和操作各种类型的对象，而不必明确指定对象的具体类型。泛型通过参数化类型实现，可以使代码更具可读性、可维护性，并减少类型转换错误。下面是泛型的一些关键概念：

1. 泛型类

泛型类允许在定义类时使用类型参数。类型参数可以在创建对象时指定，从而决定该对象的实际类型。例如：

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

在这个例子中，T 是一个类型参数，当实例化 Box 类时可以指定类型：

Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
System.out.println(stringBox.getContent()); // 输出：Hello

2. 泛型方法

泛型方法允许方法在声明时指定类型参数。即使类本身不是泛型类，方法也可以是泛型的。例如：

public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

这里的 T 是方法级别的类型参数，可以传入任何类型的数组：

Integer[] intArray = {1, 2, 3};
String[] strArray = {"A", "B", "C"};

printArray(intArray);  // 输出：1 2 3
printArray(strArray);  // 输出：A B C

3. 泛型接口

接口也可以是泛型的。例如，定义一个泛型接口 Comparable<T>：

public interface Comparable<T> {
    int compareTo(T o);
}

实现此接口的类可以指定 T 的类型：

public class Person implements Comparable<Person> {
    private String name;
    
    @Override
    public int compareTo(Person other) {
        return this.name.compareTo(other.name);
    }
}

4. 限定通配符

泛型可以通过使用限定通配符（? extends T 和 ? super T）来限定类型范围。

? extends T: 表示可以传入 T 或 T 的子类。
? super T: 表示可以传入 T 或 T 的父类。

例如：

public void printNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

? extends Number 允许传入 Integer、Double 等 Number 的子类。

5. 泛型的优点

类型安全：在编译时检查类型，减少运行时错误。
代码重用：泛型可以用于各种类型，减少重复代码。
可读性和维护性：无需在代码中使用类型转换，使代码更清晰。

6. 类型擦除

Java 的泛型在编译后会进行类型擦除，即在运行时泛型信息被删除，所有泛型类型参数都替换为它们的边界类型（如果没有指定边界，则为 Object）。这意味着泛型仅在编译时有效，编译后的字节码中不包含泛型类型信息。

7. 使用注意事项

不能实例化泛型类型的数组。
泛型类型不能是原始数据类型（如 int、char 等）。
静态成员不能引用泛型类型参数。

Java 的泛型机制使得代码更具灵活性和安全性，特别是在涉及集合、容器类等情况下，泛型的使用极大地提高了代码的复用性与安全性。

在 Java 面试中，关于泛型的提问通常会涵盖基础概念、应用场景以及一些可能涉及到边界情况的高级问题。以下是常见的几类问题及其回答思路：

1. 什么是 Java 泛型？为什么要使用泛型？

回答思路：

泛型是 Java 的一种类型参数化机制，允许在类、接口和方法中定义通用的、类型安全的代码。
泛型提供了在编译时进行类型检查的能力，避免了类型转换错误，并提高了代码的可读性和可维护性。
泛型让代码更加通用，减少重复。

2. Java 泛型的实现机制是什么？泛型的类型擦除（Type Erasure）是如何工作的？

回答思路：

Java 的泛型在编译时通过类型擦除实现，泛型类型参数会在编译后被替换为它们的限定类型（默认是 Object），这意味着在运行时并不保留具体的泛型类型信息。
因为类型擦除，泛型类型在运行时不可用于反射，也不能创建泛型类型的数组。
示例：List<Integer> 和 List<String> 在编译后实际上是相同的类型，即 List。

3. Java 中的泛型通配符是什么？它们的作用和使用场景？

回答思路：

? 是 Java 泛型中的通配符，用来表示未知的类型。
? extends T 用于表示上界通配符，限制可以传入 T 或 T 的子类，常用于读取数据。
? super T 表示下界通配符，限制可以传入 T 或 T 的父类，常用于写入数据。
讨论何时使用无界通配符（?）和有界通配符，特别是在集合类的 API 设计中。

4. 你能解释一下泛型的协变和逆变吗？在什么场景下使用？

回答思路：

协变：如果 A 是 B 的子类，List<? extends B> 表示的类型可以接受 List<A>。
逆变：如果 A 是 B 的子类，List<? super A> 表示的类型可以接受 List<B>。
这些概念通常用于保证泛型集合的安全性，特别是在读和写的场景下。

5. 泛型类、泛型接口和泛型方法有什么不同？

回答思路：

泛型类是在类的定义中引入了类型参数，用于定义更通用的类。
泛型接口和泛型类类似，只是应用在接口上。
泛型方法允许在方法中引入类型参数，与类或接口的泛型无关。即使类不是泛型的，也可以定义泛型方法。

6. 为什么 Java 的泛型不支持原始数据类型（如 int、char）？

回答思路：

Java 泛型不支持原始数据类型，因为类型擦除机制将泛型类型参数替换为 Object 或边界类型，而原始数据类型不是 Object 的子类。
可以通过包装类（如 Integer、Character）来使用原始数据类型。

7. 你能举例说明 Java 泛型的实际应用场景吗？

回答思路：

泛型常用于集合框架中，如 List<T>、Map<K, V>，通过泛型实现了集合的类型安全。
在自定义类、接口和工具方法中，泛型提供了高度灵活的代码实现，避免了重复。
讨论你在项目中如何使用泛型类和方法来解决特定问题。

8. 如何在泛型中使用多个边界？

回答思路：

使用 T extends A & B 来限制泛型参数同时是 A 和 B 的子类型。

例如：

public <T extends Comparable<T> & Serializable> void sort(T[] array) {
    // 方法实现
}

9. 你能解释一下泛型和反射的关系吗？为什么泛型在运行时不可知？

回答思路：

由于类型擦除，泛型参数在运行时是不可知的，所以通过反射无法直接获取泛型的具体类型。
讨论如何通过 Type 和 ParameterizedType 等 Java 反射 API 获取泛型的实际类型参数。

10. Java 泛型有哪些限制？

回答思路：

泛型不支持原始数据类型。
不能创建泛型数组。
泛型类的静态字段不能引用泛型类型。
由于类型擦除，无法在运行时获知泛型的具体类型。

准备 Java 泛型相关面试时，建议深入理解这些问题的细节，并能结合实际项目经验进行举例说明。
在 Spring Boot 中，Java 的泛型广泛应用于各个层面，尤其是在依赖注入、数据访问层、REST API、服务层等方面。通过使用泛型，Spring Boot 能够提供更灵活、可扩展的组件和接口定义。以下是一些 Spring Boot 中常见的泛型应用场景：

1. `CrudRepository` 和 `JpaRepository`

Spring Data JPA 提供的 CrudRepository 和 JpaRepository 接口是泛型接口，允许开发者定义通用的数据访问层。通过泛型，可以在不重复编写数据访问逻辑的情况下，为不同实体类型创建对应的 Repository。

public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
    <S extends T> S save(S entity);
    Optional<T> findById(ID id);
    Iterable<T> findAll();
    void delete(T entity);
}

这里的 T 是实体类型，ID 是实体的主键类型。例如：

public interface UserRepository extends JpaRepository<User, Long> {
}

这个 UserRepository 针对 User 实体，使用 Long 作为主键类型，JpaRepository<User, Long> 通过泛型让代码更加通用。

2. `RestController` 返回泛型类型

在编写 RESTful 接口时，Spring Boot 的 @RestController 可以通过泛型灵活地返回不同类型的数据。例如，返回统一格式的 API 响应：

public class ApiResponse<T> {
    private int status;
    private String message;
    private T data;

    // 构造函数、getter和setter省略
}

然后可以在控制器中返回不同类型的响应：

@RestController
public class UserController {

    @GetMapping("/users/{id}")
    public ApiResponse<User> getUser(@PathVariable Long id) {
        User user = userService.findUserById(id);
        return new ApiResponse<>(200, "Success", user);
    }

    @GetMapping("/users")
    public ApiResponse<List<User>> getAllUsers() {
        List<User> users = userService.findAllUsers();
        return new ApiResponse<>(200, "Success", users);
    }
}

通过使用泛型，ApiResponse<T> 可以适应不同的数据类型，而不需要为每种返回类型编写单独的响应类。

3. `@RequestBody` 和泛型

在处理 HTTP 请求的过程中，Spring Boot 允许使用泛型来解析请求体中的数据。例如，可以定义一个通用的请求类来处理不同类型的请求体：

public class RequestWrapper<T> {
    private T body;

    // 构造函数、getter和setter省略
}

然后在控制器中使用泛型处理请求体：

@PostMapping("/submit")
public ResponseEntity<String> submitData(@RequestBody RequestWrapper<User> request) {
    User user = request.getBody();
    // 处理 user 对象
    return ResponseEntity.ok("Data received");
}

4. 服务层中的泛型

在服务层中，使用泛型可以减少代码重复，定义通用的业务逻辑。例如，可以为不同实体编写通用的服务类：

public interface GenericService<T, ID> {
    T save(T entity);
    Optional<T> findById(ID id);
    List<T> findAll();
    void deleteById(ID id);
}

然后为不同实体类型创建具体的实现类：

@Service
public class UserService implements GenericService<User, Long> {

    @Autowired
    private UserRepository userRepository;

    @Override
    public User save(User user) {
        return userRepository.save(user);
    }

    @Override
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }

    @Override
    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}

5. 事件机制中的泛型

Spring 提供的事件机制也利用了泛型。例如，ApplicationEventPublisher 可以发布泛型事件：

public class GenericEvent<T> extends ApplicationEvent {
    private T eventData;

    public GenericEvent(Object source, T eventData) {
        super(source);
        this.eventData = eventData;
    }

    public T getEventData() {
        return eventData;
    }
}

事件监听器可以根据类型参数来监听不同类型的事件：

@Component
public class GenericEventListener<T> implements ApplicationListener<GenericEvent<T>> {

    @Override
    public void onApplicationEvent(GenericEvent<T> event) {
        System.out.println("Received event with data: " + event.getEventData());
    }
}