Java泛型深入解读：泛型类与泛型接口的完全指南

# 1. Java泛型基础回顾

Java泛型是Java SE 5.0引入的特性，它为集合添加了类型安全的特性，并使编写通用代码成为可能。在回顾基础之前，我们需要明白泛型的主要目的是为了在编译期间提供更严格的类型检查，同时避免运行时的类型转换错误。

## 1.1 泛型的引入动机

Java早期版本集合框架中，所有对象都作为`Object`处理，这样带来了两个主要问题：

- **类型转换的繁琐**：使用集合时，每个元素取出来时都需要进行显式的类型转换。
- **类型安全的缺失**：如果类型转换错误，会导致`ClassCastException`，只能在运行时发现。

// 示例：早期Java集合使用时类型转换的繁琐和风险
List list = new ArrayList();
list.add("Hello");
list.add(123);
for (Object obj : list) {
    String str = (String) obj; // 显式类型转换，可能抛出ClassCastException
}

## 1.2 泛型的基本概念

引入泛型后，可以为集合声明元素类型。编译器会进行类型检查，确保类型安全，并在编译时自动插入必要的类型转换，减少了运行时的异常。

// 示例：使用泛型声明集合元素的类型
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123); // 编译错误，无法添加非字符串元素
for (String str : list) {
    System.out.println(str);
}

通过以上示例，我们看到泛型如何简化代码并增加安全性，是Java集合框架的关键特性之一。泛型不仅仅用于集合，它也可以用在类、接口和方法中，让代码更加通用和安全。在接下来的章节中，我们将深入探讨泛型类、泛型接口的设计与实现，以及泛型与继承、多态的融合等更多细节。

# 2. 泛型类的设计与实现

### 2.1 泛型类的基本概念

#### 2.1.1 泛型类的定义

泛型类是Java泛型编程中的核心概念之一，它允许在类声明时使用一种或多种类型参数。在定义泛型类时，通常会在类名后面添加一个或多个类型变量，用尖括号括起来。这些类型变量在类体内部可以像普通的引用类型一样使用。

public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

在上面的例子中，`Box<T>`是一个泛型类，其中的`T`是一个类型变量，它代表了该类实例化时所指定的类型。在`Box`类的`set`和`get`方法中，`T`就代表了传递给`Box`类的具体类型。

#### 2.1.2 泛型类的使用实例

泛型类可以用来定义各种数据结构，例如集合、映射等。使用泛型类可以使这些数据结构在保持类型安全的同时，具有高度的可复用性。

public class Main {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.set(10);
        int value = integerBox.get();
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello World");
        String message = stringBox.get();
        System.out.println("Integer Value: " + value);
        System.out.println("String Value: " + message);
    }
}

在这个使用实例中，创建了两个`Box`类的实例，一个是`Box<Integer>`用于存储整数，另一个是`Box<String>`用于存储字符串。通过使用泛型类，可以确保存储在`Box`类中的数据类型是安全的，编译时就会检查类型错误。

### 2.2 泛型类的类型参数

#### 2.2.1 类型参数的作用域和限制

类型参数在泛型类中的作用域限定在类体内。它们可以用在字段、方法的返回类型、方法参数以及本地变量声明中。类型参数可以被声明为受约束的，这意味着它们可以被限制为某些特定的类型。

public class ArrayAlg {
    public static <T extends Comparable<T>> T min(T[] a) {
        if (a == null || a.length == 0) return null;
        T smallest = a[0];
        for (T element : a) {
            if (***pareTo(smallest) < 0) {
                smallest = element;
            }
        }
        return smallest;
    }
}

在这个例子中，`min`方法的类型参数`T`被限制为实现了`Comparable<T>`接口的类型，这样`T`类型的对象就可以使用`compareTo`方法进行比较。类型参数的这种限制可以增强代码的安全性。

#### 2.2.2 类型参数的多重界限

类型参数可以有多个界限，即可以指定一个类型参数必须实现多个接口，或者继承某个类并且实现多个接口。

public class Worker<T extends Employee & Cloneable> {
    //...
}

在这个例子中，`T`必须是一个`Employee`的子类型，同时还必须实现`Cloneable`接口。多重界限使得类型参数可以同时承担多个角色，为泛型编程提供了更大的灵活性。

### 2.3 泛型类与继承关系

#### 2.3.1 泛型类的子类型化

在Java中，泛型类的子类型化是基于它们的类型参数的。一个泛型类的子类型必须为基类型的每个类型参数提供一个类型，这个类型要么与基类型相同，要么是基类型的一个子类型。

class Glass<T> {
    //...
}

class Plastic<T> extends Glass<T> {
    //...
}

class TransparentGlass extends Plastic<Boolean> {
    //...
}

在上述代码中，`Plastic<T>`是`Glass<T>`的子类型化，只要`Plastic`类提供了与`Glass`类相同的类型参数。同样，`TransparentGlass`是`Plastic<Boolean>`的子类型化，因为`Boolean`是`T`的一个具体类型。

#### 2.3.2 类型擦除与继承规则

Java中的泛型是通过类型擦除来实现的，这意味着在运行时，泛型类型信息是不可用的。类型擦除也意味着继承规则与非泛型类有所不同。

class NonGenericBox {
    //...
}

class GenericBox<T> extends NonGenericBox {
    //...
}

上述代码会编译出错，因为类型擦除后，`GenericBox<T>`和`NonGenericBox`在运行时都会被视为`Object`，这违反了Java的继承规则。

### 2.4 泛型类的高级特性

#### 2.4.1 类型推断与通配符

Java编译器可以推断出泛型类型参数的类型，这个过程称为类型推断。通配符`?`允许在不知道具体类型参数的情况下，仍然能使用泛型类或者方法。

Box<?> wildcardBox = new Box<Integer>();
wildcardBox.set(new Integer(42));
Integer value = wildcardBox.get();

在这个例子中，尽管`wildcardBox`被声明为使用通配符`?`的泛型类型，编译器还是能根据`set`方法调用推断出`wildcardBox`的类型参数是`Integer`。

#### 2.4.2 反射与泛型类

反射API允许在运行时动态地检查类、接口、字段、方法和构造器的泛型信息。但是，由于类型擦除，某些泛型信息在运行时是不可用的。

public static void printGenericInfo(Class<?> clazz) {
    if (clazz.isAssignableFrom(Box.class)) {
        Type genericSuperclass = clazz.getGenericSuperclass();
        if (genericSuperclass instanceof ParameterizedType) {
            Parameterized