Java泛型

一、简介

Java泛型是一种类型参数化的机制，可以让我们在编写代码时通过参数指定数据类型，提高代码的可重用性和类型安全性。

二、类型参数化

1. 声明泛型类和接口

public class GenericClass<T> {
    // 泛型类的成员变量和方法
}

public interface GenericInterface<T> {
    // 泛型接口的方法声明
}

2. 泛型类型参数的命名规范

在命名类型参数时，通常使用单个大写字母表示，以表明它是一个占位符类型。

3. 类型参数的限定和约束

可以通过使用extends关键字对类型参数进行限定，约束它必须是某个特定类型或其子类。

public class GenericClass<T extends Number> {
    // 限定泛型类型为Number及其子类
}

三、泛型方法

1. 定义和使用泛型方法

public <T> void genericMethod(T param) {
    // 泛型方法的实现
}

2. 泛型方法与重载的关系

泛型方法可以与普通方法进行重载，通过参数类型的不同来区分调用。

3. 泛型方法的类型推断机制

根据方法参数的具体类型，编译器可以自动推断泛型类型，从而省略了类型参数的显式指定。

四、通配符与边界

1. 上界通配符

使用 ? extends 表示通配符上界，限定泛型类型必须是某个特定类或其子类。

public void processList(List<? extends Number> list) {
    // 可以接收Number及其子类的List
}

2. 下界通配符

使用 ? super 表示通配符下界，限定泛型类型必须是某个特定类或其父类。

public void processList(List<? super Integer> list) {
    // 可以接收Integer及其父类的List
}

3. 无界通配符

使用 ? 表示无界通配符，表示可以接收任意类型的泛型实参。

public void processList(List<?> list) {
    // 可以接收任意类型的List
}

4. 通配符的使用场景和限制

通配符可以用于灵活处理不同类型的数据，但在方法内部只能使用Object类型，无法使用泛型类型参数的具体方法。

五、泛型类的继承与接口的实现

1. 泛型类的继承关系

子类可以通过继承父类的泛型类型参数，并在实例化时指定具体类型。

public class SubClass<T> extends SuperClass<T> {
    // 子类继承父类的泛型类型参数
}

2. 泛型接口的实现关系

实现泛型接口时，可以保持泛型类型参数一致，也可以重新指定类型参数。

public class ImplClass<T> implements GenericInterface<T> {
    // 实现泛型接口，保持类型参数一致
}

public class AnotherImplClass implements GenericInterface<Integer> {
    // 实现泛型接口，重新指定类型参数为Integer
}

3. 泛型在继承和接口实现中的注意事项

在继承时，子类如果不指定具体类型，将使用父类的泛型类型参数。在接口实现时，可以根据需要重新指定泛型类型参数。

六、类型擦除和桥方法

1. 泛型的类型擦除机制

在编译后，泛型类型参数会被擦除为原始类型或限定类型，并进行类型转换。
泛型的类型擦除机制：在编译时，Java的泛型信息只存在于代码编译阶段，在生成的字节码中会将泛型类型参数擦除为原始类型或限定类型。这意味着，在运行时无法获取泛型类型的具体信息。例如，List和List在编译后会变成相同的List类型。

2. 桥方法的生成和作用

编译器会生成桥方法来处理泛型类型的继承和实现的类型转换问题。
桥方法的生成和作用：为了保持泛型类型的继承和实现关系的一致性，编译器会生成桥方法（bridge method）。桥方法是指在父类或接口中定义了一个泛型方法，在子类或实现类中生成的一个非泛型的方法，用于处理类型转换的问题。桥方法的作用是确保子类或实现类可以正确地覆盖父类或接口中的泛型方法。

3. 泛型与反射的关系

由于类型擦除的特性，通过反射获取泛型类型信息时会受到一定的限制。
泛型与反射的关系：由于类型擦除的特性，通过反射获取泛型类型信息时会受到一定的限制。在运行时，无法直接获取泛型类型的具体参数类型，而只能获取到原始类型。但是，可以通过反射中的ParameterizedType等接口和类来获取泛型参数的信息。需要注意的是，反射操作泛型类型时需要进行额外的判断和处理，以避免类型安全问题和异常情况。

七、泛型与数组

1. 泛型数组的创建和使用

无法直接创建带有泛型参数的数组，可以使用通配符或使用类型转换来处理。

1. 泛型数组的创建和使用：在Java中，无法直接创建带有泛型参数的数组，例如 List[] array = new List[10]; 是不允许的。这是因为泛型数组的静态类型检查会导致编译时错误。为了解决这个问题，可以使用通配符或进行类型转换。

   • 使用通配符：可以创建泛型数组的引用，然后将其指向具体类型的数组对象。例如，可以声明一个泛型数组引用 List[] array;，然后将其指向 List[] 类型的数组对象。

   List<?>[] array = new List<?>[10];
   array[0] = new ArrayList<String>();  // 正确
   

   • 使用类型转换：可以将创建的原始类型数组转换为泛型数组。这需要进行强制类型转换，并且要确保数组对象的真实类型与转换后的泛型类型是兼容的。

   List<String>[] array = (List<String>[]) new List[10];
   array[0] = new ArrayList<String>();  // 正确
   

2. 泛型数组的限制和注意事项

由于数组的协变性，编译器无法对泛型数组的类型进行检查，需要注意可能出现的类型安全问题。
2. 泛型数组的限制和注意事项：由于数组的协变性（数组引用可以指向其子类类型的数组对象），编译器无法对泛型数组的类型进行检查。这可能导致类型安全问题。例如，在运行时，如果将错误类型的对象存储到泛型数组中，可能会引发 ClassCastException 异常。

List<String>[] array = (List<String>[]) new List[10];
array[0] = new ArrayList<Integer>();  // 编译时没有错误，但在运行时会引发异常

因此，在使用泛型数组时需要格外小心，确保类型的一致性和安全性。如果遇到无法创建泛型数组的情况，可以考虑使用集合类（如 ArrayList）等替代方案来实现相似的功能。

八、局限性和常见问题

1. 类型擦除带来的限制：

类型擦除是Java泛型机制的一个重要特性，但它也带来了一些限制。由于在运行时无法获取泛型类型参数的具体实例化类型，因此无法对泛型类型的实例化对象进行一些操作，例如获取实例化类型的构造函数、创建实例、访问实例属性等。

2. 泛型中的常见错误和解决方法：

在使用泛型类或方法时，可能会出现编译错误或运行时异常。一些常见的问题包括：

• 未指定泛型类型参数；
• 指定了错误的泛型类型参数；
• 使用了未检查的转换；
• 使用了不兼容的类型参数；
• 等等。

这些问题可以通过仔细观察编译器错误信息并逐个排查解决。在使用泛型类型时，需要特别注意类型安全和代码规范，确保代码的正确性和可读性。

3. 引用泛型类型的静态成员的问题：

由于在泛型类型中无法直接使用类型参数来引用静态成员，如静态变量或静态方法，因此需要通过其他手段来解决。其中一种方式是使用泛型类型通配符 或泛型参数限定符 或 ，来表示泛型类型参数的类型。

public class Test<T> {
    public static int count;  // 静态成员变量
    public static <T> void method(T t) {  // 静态方法
        ...
    }

    public static void main(String[] args) {
        Test<?> test1 = new Test<>();
        int c1 = test1.count;        // 正确，使用通配符引用静态变量
        test1.method("test");        // 正确，使用通配符引用静态方法

        Test<? extends Number> test2 = new Test<>(); // 使用泛型参数限定符引用泛型类型
        int c2 = test2.count;
        // test2.method("test");      // 错误，类型不匹配
        test2.method(1.23);           // 正确，传递 Number 或其子类类型的参数
    }
}

总之，泛型机制带来了很多便利和强大的功能，但也需要我们在使用时注意一些限制和常见问题，并遵循良好的编码规范，确保代码的正确性和可读性。

九、总结

Java泛型是一种强大的编程机制，通过参数化类型可以提高代码的可重用性和类型安全性。掌握泛型的基本语法和特性，能够更好地应用于实际开发中。