说说对泛型的理解？

在Java开发过程中，泛型（Generics） 是一个非常基础且重要的语法特性。它不仅提升了代码的复用性与类型安全，还大大增强了集合、工具类等容器的灵活性。本文将结合理论和详细代码示例，从泛型的原理、常见用法、PECS原则等方面，系统讲解什么是Java泛型，以及如何正确高效地使用泛型。

---

一、什么是泛型

泛型，顾名思义，就是“参数化类型”。通俗的说，泛型允许在定义类、接口、方法时，将类型作为参数进行传递，使代码可以应用于多种不同的类型。

本质作用：

• 让同一份代码适配不同类型的数据
• 在编译期提供类型检查，避免类型转换异常

例子：没有泛型的集合（JDK1.5之前）

List list = new ArrayList();
list.add("string");
list.add(123); // 没有任何报错
// 取出元素需要强转
String str = (String) list.get(0); // 正常
String str2 = (String) list.get(1); // 运行时报ClassCastException

例子：有泛型的集合

List<String> list = new ArrayList<>();
list.add("string");
// list.add(123); // 编译报错！
String str = list.get(0); // 不需要强转，类型安全

---

二、泛型的基本使用

1. 泛型类

public class Box<T> {
    private T value;
    public void setValue(T value) { this.value = value; }
    public T getValue() { return value; }
}

public static void main(String[] args) {
    Box<Integer> intBox = new Box<>();
    intBox.setValue(123);
    int i = intBox.getValue(); // 自动类型检查，无需强转

    Box<String> strBox = new Box<>();
    strBox.setValue("hello");
    String s = strBox.getValue(); // 类型安全
}

2. 泛型方法

public class Utils {
    // 泛型方法声明在返回值前加 <T>
    public static <T> void printArray(T[] array) {
        for (T t : array)
            System.out.println(t);
    }
}

public static void main(String[] args) {
    Integer[] nums = {1, 2, 3};
    String[] strs = {"a", "b"};
    Utils.printArray(nums); // 自动识别T为Integer
    Utils.printArray(strs); // 自动识别T为String
}

3. 泛型接口

public interface Converter<F, T> {
    T convert(F from);
}

public class StringToIntegerConverter implements Converter<String, Integer> {
    @Override
    public Integer convert(String from) {
        return Integer.valueOf(from);
    }
}

---

三、通配符 <?> 详解

1. 基础通配符

<?> 代表未知类型。例如，可以接收任意类型的List：

public static void printList(List<?> list) {
    for(Object o : list) System.out.println(o);
}

2. 上界通配符（extends）

<? extends Number> 代表某种Number的子类型，常用于只读（取数据）场景。

public static void sumList(List<? extends Number> numbers) {
    double sum = 0;
    for (Number n : numbers) sum += n.doubleValue();
    System.out.println("Sum: " + sum);
}

3. 下界通配符（super）

<? super Integer> 代表Integer或其父类类型，常用于只写（存数据）场景。

public static void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
    // 不能读取到具体类型（只能当Object用）
}

口诀：

• Producer Extends（PE） —— 只从集合取数据用 extends
• Consumer Super（CS） —— 只向集合存数据用 super

---

四、泛型常见应用和典型代码

1. 类型擦除现象

Java的泛型是“伪泛型”，编译后会进行类型擦除、转为原始类型。例如：

List<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();

System.out.println(stringList.getClass() == intList.getClass()); // true

意味着“泛型信息只存在于编译期，运行时被擦除”。

2. 泛型不能用于静态变量

public class Demo<T> {
    // static T field; // 编译不通过，静态变量无法使用泛型类型
}

3. 数组与泛型

// T[] arr = new T[10]; // 错误，不能直接创建泛型数组
Object[] arr = new Integer[10]; // 可行，但存在类型转型风险

---

五、实战代码解析：泛型工具类与PECS用法

以集合复制为例，演示PECS原则：

// 只读 - 泛型上界
public static double sum(List<? extends Number> list) {
    double result = 0;
    for (Number n : list) result += n.doubleValue();
    return result;
}
// 只写 - 泛型下界
public static <T> void copy(List<? super T> dest, List<T> src) {
    for (T t : src)
        dest.add(t);
}

public static void main(String[] args) {
    List<Integer> src = Arrays.asList(1, 2, 3);
    List<Number> dest = new ArrayList<>();
    copy(dest, src); // dest可以是Number，可以是Object...

    System.out.println(sum(dest));
}

---

六、泛型的好处与注意事项

优点：

• 类型安全，编译阶段预防类型错误
• 代码复用，同一结构适配多种类型
• 可读性强，类型清晰可见、减少强解

注意事项：

• 泛型类型在运行时会被擦除（无实例化类型），不能用==或instanceof判断泛型参数类型
• 泛型类不能直接使用基本类型（如Box<int>会报错，只能用Box<Integer>）
• 静态上下文（static变量和方法）不能引用类的泛型参数