别让泛型成为你的“能力天花板”！一文吃透T、E、K、V、?，这才是面试官想听到的答案！-优快云博客

你有没有在写 Java 的时候看到一堆泛型参数：<T>、<E>、<K, V>、<?>，然后心想，“这都什么鬼？哪个是哪个？”别慌，这其实没你想的那么抽象。今天我们就用最朴实的方式，把这些泛型的含义和用法都理一遍，代码都是真实可跑的例子，看完你就彻底不怕它了。

一、泛型到底是干嘛的？

泛型，说白了就是一种“模板”。比如你想写一个存放对象的容器类，既能放 String，也能放 Integer，还得能放自定义对象，那不用泛型的话，你可能会写成这样：

public class Box {    private Object value;    public void set(Object value) { this.value = value; }    public Object get() { return value; }}

表面上看挺通用，但取出来你得强转：

Box box = new Box();box.set("hello");String s = (String) box.get(); // 不强转还不行

一旦你强转错类型，比如拿个 Integer 强转成 String，直接 ClassCastException。

这就不优雅了，泛型就是为了解决这种问题的。换成泛型版：

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

这样你创建时就指定类型：

Box<String> box = new Box<>();box.set("hello");String s = box.get(); // 再也不用强转

是不是清爽多了？

二、T、E、K、V 都是什么鬼？

其实这些字母没啥神秘的含义，它们只是“约定俗成”的写法。你要非写 <A>、<X> 也行，就是别人看你代码可能懵。

一般用法是这样的：

字母	含义	常见场景
T	Type（类型）	单个通用类型，如 `List<T>`
E	Element（元素）	集合中的元素类型，如 `List<E>`
K	Key（键）	键值对中的键，如 `Map<K,V>`
V	Value（值）	键值对中的值，如 `Map<K,V>`
?	通配符（unknown type）	表示未知类型，比如方法参数中不关心具体类型

举个例子你就懂了：

Map<Integer, String> map = new HashMap<>();map.put(1, "Java");map.put(2, "泛型");

这里 K 就是 Integer，V 就是 String。所以泛型的意思其实很直白，就是定义一个“类型变量”，用的时候再指定。

三、T 和 ? 的区别（这是面试常考点）

很多人一看到 ? 就蒙了，明明也是“泛型”，为啥不写 T 呢？其实它俩的区别是这样的：

T 是在定义类或方法时声明的类型变量。
? 是在使用泛型时，表示未知类型。

比如你定义一个方法：

public <T> void printList(List<T> list) {    for (T item : list) {        System.out.println(item);    }}

这里 <T> 是声明，这个方法可以接受任何类型的 List。但是下面这个：

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

这里用的是 ?，意思是“我不在乎它是什么类型，只要是个 List 就行”。

区别就在于：<T> 让你在方法中还可以知道类型，<?> 则完全放弃了类型信息。

四、上界通配符和下界通配符

你可能还见过这种奇怪的写法：

List<? extends Number>List<? super Integer>

别急，我们慢慢拆。

1. `? extends T`：上界通配符（表示“是 T 或其子类”）

比如：

public void printNumbers(List<? extends Number> list) {    for (Number n : list) {        System.out.println(n);    }}

这个方法能接受 List<Integer>、List<Double> 等，只要元素是 Number 的子类都行。但注意，你不能往里面加元素，因为编译器不知道你传进来的是 Integer 还是 Double。

2. `? super T`：下界通配符（表示“是 T 或其父类”）

比如：

public void addIntegers(List<? super Integer> list) {    list.add(1); // OK    // list.add(1.5); // 编译错误}

这个方法能接受 List<Integer>、List<Number>、List<Object>。因为 Integer 是它们的子类。它适用于“往容器里放”的场景。

一句口诀记住：

“extends 读、super 写”——用 extends 时只读不写，用 super 时只写不读。

五、泛型方法的定义和使用

泛型不仅能加在类上，也能加在方法上：

public class GenericMethodExample {    public static <T> void print(T value) {        System.out.println(value);    }    public static void main(String[] args) {        print(123);          // 自动推断为 Integer        print("Hello");      // 自动推断为 String        print(3.14);         // 自动推断为 Double    }}

是不是很灵活？方法级的泛型特别适合工具类，比如排序、拷贝、比较等。

六、泛型擦除（Java 编译期的“小秘密”）

其实 Java 的泛型只是编译期语法糖，在运行时会被“擦除”。比如 List<String> 和 List<Integer> 到运行时其实是一样的类型：

List<String> list1 = new ArrayList<>();List<Integer> list2 = new ArrayList<>();System.out.println(list1.getClass() == list2.getClass()); // true

输出：true。

这就是“类型擦除”。所以泛型信息在运行时是拿不到的，像下面这样会报错：

if (list1 instanceof List<String>) { } // 编译错误

一个完整的例子

来个综合的小例子，把上面的点都串起来：

class Pair<K, V> {    private K key;    private V value;    public Pair(K key, V value) {        this.key = key;        this.value = value;    }    public K getKey() { return key; }    public V getValue() { return value; }}class Util {    publicstatic <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {        return p1.getKey().equals(p2.getKey()) &&               p1.getValue().equals(p2.getValue());    }}publicclass TestGeneric {    public static void main(String[] args) {        Pair<Integer, String> p1 = new Pair<>(1, "Java");        Pair<Integer, String> p2 = new Pair<>(1, "Java");        boolean same = Util.compare(p1, p2);        System.out.println(same); // true    }}

这里同时用到了 <K, V> 泛型和泛型方法 <K, V>，完全类型安全，不需要任何强转。