泛型作用

类型安全：在编译时检查类型，避免运行时类型转换错误。
代码复用：用同一套逻辑处理不同类型的数据，减少重复代码。
消除强制类型转换：编译器自动处理类型转换，代码更简洁。

泛型语法

(1) 泛型类/接口

// 定义一个泛型类
public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}
// 使用示例
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
String value = stringBox.getContent(); // 无需强制转换

(2) 泛型方法

// 定义一个泛型方法
public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
}

// 使用示例
Integer[] intArray = {1, 2, 3};
printArray(intArray); // 输出: 1 2 3

String[] strArray = {"A", "B", "C"};
printArray(strArray); // 输出: A B C

类型参数命名习惯

T：Type（类型），通用的类型变量，可以代表任何类型

public interface Iterable<T> {}

E：Element（集合中的元素）

public interface Collection<E> extends Iterable<E> {}

K：Key（键）
V：Value（值）

public interface Map<K,V> {}

N：Number（数值类型）
自定义：如 < Student >也可，但推荐使用单字母大写。

类型通配符（Wildcards）

(1) 无界通配符 <?>表示“未知类型”

表示“未知类型”，常用于不需要关心具体类型的场景。

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

(2) 上界通配符 <? extends T>表示“T 或 T 的子类”。

// 接收 Number 或其子类（如 Integer, Double）
public void processNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num.doubleValue());
    }
}

(3) 下界通配符 <? super T>表示“T 或 T 的父类”。

// 向集合中添加 Integer 或其父类（如 Number, Object）
public void addIntegers(List<? super Integer> list) {
    list.add(10);
    list.add(20);
}

注意事项

类型擦除（Type Erasure）

编译时行为：泛型信息在编译后会被擦除，替换为 Object 或上界类型。
运行时限制：无法获取泛型的具体类型参数。

//其中泛型类型为String，代表元素类型是Sring
List<String> list = new ArrayList<>();
if (list instanceof ArrayList<String>) { // 编译错误！无法检查泛型类型
    // ...
}

基本类型不能用泛型

// 错误写法
List<int> list = new ArrayList<>(); 
// 正确写法
List<Integer> list = new ArrayList<>();

静态成员不能使用类的泛型参数

public class Box<T> {
    // 错误写法
    private static T staticField; 
}

静态static 是类加载作用，即.java-->.class对象，静态成员不属于任何特定类型的实例

在Java中，泛型只是一个占位符，必须在传递类型后才能使用。类实例化时才能传递真正的类型参数
由于静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数时，静态方法就已经加载完成。因此，静态方法不能使用/访问泛型类中的泛型

泛型数组的限制

// 错误写法：不能直接创建泛型数组
T[] array = new T[10]; 
// 正确写法（通过强制类型转换）
T[] array = (T[]) new Object[10];

常见应用场景

集合框架

List<String> names = new ArrayList<>();
Map<Integer, String> idToName = new HashMap<>();

工具类

public class Pair<K, V> {
    private K key;
    private V value;
    // getter/setter...
}

回调接口

public interface Callback<T> {
    void onSuccess(T result);
    void onError(String message);
}

总结

核心目标：通过类型参数化，提高代码的复用性和安全性。

关键语法：
1.泛型类：class Box { … }
2.泛型方法： void method(T param) { … }
3.通配符：<?>、<? extends T>、<? super T>

避免陷阱：类型擦除、基本类型限制、静态上下文问题。