泛型程序设计

Java 泛型（Generics）是 Java 5 引入的一个重要特性，它允许在编译时期指定类、接口或方法可以处理的数据类型，从而提高代码的类型安全性和重用性。泛型程序设计是一种将数据类型参数化的编程方式，使得代码可以更加通用，并且可以在编译时进行类型检查，避免在运行时出现类型转换错误。

1. 泛型类

Java 泛型类是一种使用泛型参数化的类，它允许在类的定义中指定一个或多个类型参数，使得类中的字段、方法和构造函数可以使用这些类型参数作为其数据类型或参数类型。通过泛型类，我们可以实现在一个类中处理不同类型的数据，从而提高代码的重用性和类型安全性。

Java 泛型类的语法格式如下：

public class ClassName<T1, T2, ..., Tn> {
    // 类的字段、方法和构造函数等定义可以使用泛型类型参数 T1, T2, ..., Tn
}

在上面的语法中，ClassName 是泛型类的类名，T1, T2, ..., Tn 是泛型类型参数。你可以根据实际需求指定一个或多个泛型类型参数，每个类型参数用逗号分隔。

下面是一个简单的例子，演示如何定义和使用泛型类：

public class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

// 使用泛型类
Box<Integer> integerBox = new Box<>(10);
int value = integerBox.getValue(); // 不需要进行类型转换，直接获取整数值

Box<String> stringBox = new Box<>("Hello, Java Generics");
String strValue = stringBox.getValue(); // 不需要进行类型转换，直接获取字符串值

在上述例子中，我们定义了一个泛型类 Box，它有一个泛型类型参数 T。通过使用泛型类型参数 T，我们可以在类中处理不同类型的数据。在使用泛型类时，通过 <Integer> 和 <String> 等类型参数来指定具体的数据类型，从而在实例化时确定 T 的类型。

2. 泛型方法

Java 泛型方法是一种在方法中使用泛型类型参数的特性。通过泛型方法，我们可以在方法的声明中使用泛型类型参数，从而使方法可以处理不同类型的数据，提高代码的重用性和类型安全性。

Java 泛型方法的语法格式如下：

public <T> returnType methodName(T arg1, T arg2, ...) {
    // 方法体
}

在上面的语法中，<T> 是泛型类型参数的声明，可以是任何合法的标识符。returnType 是方法的返回类型，可以是具体的数据类型，也可以是使用泛型类型参数 T。

下面是一个简单的例子，演示如何定义和使用泛型方法：

public class GenericMethods {
    public <T> void printArray(T[] array) {
        for (T item : array) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public <T> T getFirstElement(T[] array) {
        if (array != null && array.length > 0) {
            return array[0];
        }
        return null;
    }
}

// 使用泛型方法
Integer[] intArray = { 1, 2, 3, 4, 5 };
String[] strArray = { "Hello", "Java", "Generics" };

GenericMethods gm = new GenericMethods();
gm.printArray(intArray); // 输出 "1 2 3 4 5 "
gm.printArray(strArray); // 输出 "Hello Java Generics "
System.out.println(gm.getFirstElement(intArray)); // 输出 "1"
System.out.println(gm.getFirstElement(strArray)); // 输出 "Hello"

在上述例子中，我们定义了一个 GenericMethods 类，其中包含两个泛型方法：printArray 和 getFirstElement。这两个方法都使用了泛型类型参数 T，可以处理不同类型的数组。

在使用泛型方法时，可以根据实际需求指定具体的类型参数，也可以让编译器根据方法参数的类型进行类型推断。

3. 类型变量的限定

在 Java 泛型中，类型变量的限定（bounded type parameters）是指对泛型类型参数进行约束，使其必须满足某些条件。这样做可以提高代码的类型安全性，并且允许泛型方法在一定的范围内操作不同类型的数据。

Java 中的类型变量限定有两种形式：上界限定和下界限定。

上界限定（Upper Bounded Wildcards）：上界限定使用 extends 关键字后跟一个类或接口名称来限定泛型类型参数。这样，泛型类型参数必须是指定类或接口的子类或实现类。
```
public <T extends SomeClass> void doSomething(T obj) {
    // 方法体
}
```
在上述例子中，<T extends SomeClass> 表示类型变量 T 必须是 SomeClass 类或其子类。这样，在方法内部可以安全地使用 SomeClass 类的成员或方法，因为 T 类型已经被限制为 SomeClass 或其子类。
使用上界限定的好处是，我们可以在泛型方法中调用指定类或接口的方法，而不用担心类型不匹配的问题。例如，如果传入的参数是 SomeClass 类的子类，我们可以调用子类独有的方法。
下界限定（Lower Bounded Wildcards）：下界限定使用 super 关键字后跟一个类名称来限定泛型类型参数。这样，泛型类型参数必须是指定类的父类。
```
public <T super SomeClass> void doSomething(T obj) {
    // 方法体
}
```
在上述例子中，<T super SomeClass> 表示类型变量 T 必须是 SomeClass 类的父类。这样，在方法内部可以安全地使用 SomeClass 类的父类的成员或方法。
使用下界限定的好处是，我们可以在泛型方法中处理指定类的父类对象，从而更灵活地操作不同类型的数据。例如，可以将不同类型的对象存储在一个数组或集合中，然后通过下界限定的泛型方法进行统一处理。

下面是一个示例，演示了上界限定和下界限定的用法：

public class GenericMethods {
    public <T extends Number> void printNumber(T number) {
        System.out.println("Number: " + number);
    }

    public <T super Integer> void printInteger(T integer) {
        System.out.println("Integer: " + integer);
    }
}

// 使用泛型方法
GenericMethods gm = new GenericMethods();
gm.printNumber(10); // 输出 "Number: 10"
gm.printNumber(3.14); // 输出 "Number: 3.14"

gm.printInteger(20); // 输出 "Integer: 20"
gm.printInteger(10); // 输出 "Integer: 10"

在上述例子中，printNumber 方法使用上界限定 T extends Number，表示类型变量 T 必须是 Number 类或其子类。printInteger 方法使用下界限定 T super Integer，表示类型变量 T 必须是 Integer 类的父类。

4. 泛型代码和虚拟机

Java 泛型是在编译器级别实现的，即在编译时期进行类型擦除（Type Erasure）。这意味着在编译后的字节码中，泛型信息会被擦除，转换成原始类型，没有泛型参数的概念。因此，Java 泛型对于虚拟机（JVM）来说是透明的，虚拟机在运行时并不知道泛型的存在。

Java 泛型代码在编译时期会进行类型检查，确保类型的安全性，但在生成的字节码中，泛型的类型信息会被擦除，并且在运行时使用原始类型。这就是所谓的类型擦除。

由于类型擦除的存在，Java 泛型在虚拟机中有一些限制和特殊情况：

泛型类型参数会被擦除为其上界（或者如果没有指定上界，则被擦除为 Object 类型）。
在使用泛型时，如果没有指定类型参数，编译器会进行类型推断，根据上下文自动推断泛型类型。
对于泛型数组，例如 List<String>[]，由于类型擦除，会被擦除为 List[]。
对于泛型方法，泛型类型参数在方法内部会被擦除，方法的字节码中不包含泛型参数的信息。
由于类型擦除，有时可能会导致编译器警告或运行时异常。例如，在使用泛型类的静态方法时，不能使用泛型类型参数作为静态方法的泛型参数。

虽然在虚拟机中，泛型的类型信息被擦除了，但通过反射机制，我们仍然可以获取泛型信息。Java 中的反射机制允许我们在运行时获取类的信息，包括泛型参数的信息。可以使用 Class 对象的一些方法来获取泛型信息，例如 getGenericSuperclass()、getGenericInterfaces() 等。

总结：Java 泛型在编译器级别实现，通过类型擦除将泛型转换为原始类型。在虚拟机中，泛型对于字节码来说是透明的，运行时不知道泛型的存在。虽然泛型信息被擦除了，但通过反射机制仍然可以在运行时获取泛型信息。

5. 限制与局限性

Java 泛型是一个强大的特性，它为我们带来了很多好处，但同时也有一些限制和局限性。下面是 Java 泛型的一些限制和局限性：

类型擦除：Java 泛型在编译时会进行类型擦除，泛型类型信息在运行时是不可用的。这导致在运行时无法直接访问泛型类型参数的具体类型。例如，List<String> 和 List<Integer> 在运行时都会被擦除为 List<Object>。
无法使用基本数据类型：Java 泛型不支持基本数据类型，只能使用对象类型。例如，不能定义 List<int>，而必须使用 List<Integer>。
无法创建泛型数组：由于类型擦除的存在，无法直接创建泛型数组。例如，不能创建 new T[]，因为在运行时无法确定泛型类型。
不能使用基于泛型类型参数的静态成员：不能在泛型类的静态成员中使用泛型类型参数，因为泛型类型参数是在实例化时确定的，而静态成员是在类加载时初始化的。
不能捕获泛型类型参数：在异常处理中，不能捕获泛型类型参数的异常。例如，不能使用 catch(T e) 来捕获异常。
不能直接实例化泛型类型参数：不能直接实例化泛型类型参数，例如不能使用 new T() 来实例化。
通配符的限制：通配符的使用有一些限制，例如不能使用 List<?> 来添加元素，只能使用 List<? extends SomeClass> 或 List<? super SomeClass>。
无法确定的类型转换：由于类型擦除，有时候可能会导致无法确定的类型转换和编译器警告。在处理复杂泛型类型时，可能需要进行显示的类型转换。
泛型类型参数不能为原始类型：不能使用原始类型作为泛型类型参数，例如不能使用 List<int>，而必须使用 List<Integer>。

尽管 Java 泛型有一些限制和局限性，但它仍然是一项非常有用的特性，可以提高代码的类型安全性和重用性。

6. 泛型类型的继承规则

Java 泛型类型的继承规则主要涉及泛型类和泛型接口的继承关系。在继承中，泛型类型参数的继承有一些特殊的规则，下面来详细介绍：

泛型类继承泛型类：

如果父类是一个泛型类，子类可以保留父类的泛型类型参数。
子类可以使用父类的泛型类型参数，并可以添加自己的类型参数。
子类可以指定父类的泛型类型参数的具体类型，也可以继续保留泛型类型参数。

// 父类是泛型类
class Box<T> {
    // 父类的泛型类型参数 T
}

// 子类可以保留父类的泛型类型参数 T，也可以添加自己的泛型类型参数 U
class ChildBox<T, U> extends Box<T> {
    // 子类可以使用父类的泛型类型参数 T，并可以添加自己的泛型类型参数 U
}

泛型接口继承泛型接口：

如果父接口是一个泛型接口，子接口可以保留父接口的泛型类型参数。
子接口可以使用父接口的泛型类型参数，并可以添加自己的类型参数。
子接口可以指定父接口的泛型类型参数的具体类型，也可以继续保留泛型类型参数。

// 父接口是泛型接口
interface Box<T> {
    // 父接口的泛型类型参数 T
}

// 子接口可以保留父接口的泛型类型参数 T，也可以添加自己的泛型类型参数 U
interface ChildBox<T, U> extends Box<T> {
    // 子接口可以使用父接口的泛型类型参数 T，并可以添加自己的泛型类型参数 U
}

泛型类继承非泛型类：

如果父类是一个非泛型类，子类可以保留父类的类型。
子类可以在实例化时为泛型类型参数指定具体类型，也可以保留泛型类型参数。

// 父类是非泛型类
class Box {
    // 父类没有泛型类型参数
}

// 子类可以保留父类的类型，也可以指定泛型类型参数的具体类型
class ChildBox<T> extends Box {
    // 子类可以保留父类的类型，也可以指定泛型类型参数的具体类型
}

需要注意的是，Java 泛型中的继承规则允许子类继承父类的泛型类型参数，并且可以在子类中使用和扩展这些泛型类型参数。子类可以在实例化时为泛型类型参数指定具体类型，也可以保留泛型类型参数。

7. 通配符类型

Java 泛型通配符类型（Wildcard Type）是用来表示未知类型的一种特殊泛型类型。通配符类型在泛型类、泛型方法和泛型接口中使用，用于增强泛型的灵活性和适用性。通配符类型使用 ? 符号表示，有三种主要形式：

无界通配符（Unbounded Wildcard）：?
- 用 ? 表示未知类型，表示可以匹配任何类型。
- 适用于只需要读取泛型集合中的元素，而不需要向集合中添加元素的情况。
```
List<?> list = new ArrayList<>();
```
上界通配符（Upper Bounded Wildcard）：? extends Type
- 使用 ? extends Type 表示未知类型必须是指定类型 Type 或其子类。
- 适用于需要从泛型集合中读取数据的情况，因为此时可以安全地将元素转换为上界类型。
```
List<? extends Number> list = new ArrayList<>();
```
下界通配符（Lower Bounded Wildcard）：? super Type
- 使用 ? super Type 表示未知类型必须是指定类型 Type 或其父类。
- 适用于需要向泛型集合中添加数据的情况，因为此时可以安全地添加指定类型及其子类的元素。
```
List<? super Integer> list = new ArrayList<>();
```

通配符类型的使用示例：

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.print(item + " ");
    }
    System.out.println();
}

List<Integer> intList = Arrays.asList(1, 2, 3);
List<String> strList = Arrays.asList("Hello", "Java", "Generics");

printList(intList); // 输出 "1 2 3 "
printList(strList); // 输出 "Hello Java Generics "

在上述例子中，printList 方法接收一个通配符类型的 List 参数，即可以接收任意类型的 List。在方法内部，我们可以安全地读取 List 中的元素，因为它们的类型是未知的。

8. 反射和泛型

Java 泛型与反射（Reflection）之间存在一些相互影响的关系。反射是一种机制，它允许在运行时获取类的信息，并且可以在运行时动态地操作类的成员、方法和构造函数等。在使用反射时，与泛型相关的类型信息也可以被获取和处理。

以下是 Java 泛型与反射之间的关系和一些常见操作：

获取泛型类型信息：通过反射可以获取类、方法和字段等的泛型类型信息。可以使用 getGenericSuperclass() 和 getGenericInterfaces() 方法来获取类的泛型超类和泛型接口信息。通过 ParameterizedType 接口可以获取泛型类型参数的具体信息。
创建泛型实例：使用反射可以在运行时创建泛型类型的实例。通过 Class 类的 newInstance() 方法可以创建一个泛型类型的对象。注意，这种方式要求泛型类必须有无参的构造函数。
获取泛型方法：可以使用反射来获取泛型类中定义的泛型方法。通过 Class 类的 getDeclaredMethods() 方法可以获取类中声明的所有方法，然后再根据方法的参数类型等信息来找到目标泛型方法。
使用泛型数组：通过反射可以获取泛型数组类型的信息。可以使用 Class 类的 getComponentType() 方法来获取数组的组件类型，进而获取泛型数组的泛型类型参数信息。
操作泛型类型：通过反射，可以在运行时动态地操作泛型类型。例如，在泛型类中可以获取泛型类型参数的信息，并根据实际情况进行类型转换和处理。

需要注意的是，由于泛型类型信息在编译时会被擦除（type erasure），因此在反射中有一些限制和注意事项：

获取泛型类型信息时，只能获取泛型参数的上界类型，而无法获取具体的类型参数。
创建泛型类型实例时，由于擦除的存在，可能会导致类型转换错误和运行时异常。
泛型数组的创建和使用也需要特殊处理，以避免类型转换错误。

综上所述，Java 泛型与反射之间的关系可以帮助我们在运行时动态地处理泛型类型，但同时也需要注意类型擦除和类型转换带来的潜在问题。在使用反射处理泛型时，需要仔细处理类型信息，以确保代码的正确性和安全性。

# 泛型程序设计

# 1. 泛型类

# 2. 泛型方法

# 3. 类型变量的限定

# 4. 泛型代码和虚拟机

# 5. 限制与局限性

# 6. 泛型类型的继承规则

# 7. 通配符类型

# 8. 反射和泛型