← 课程目录 🚀 从零到一
📐 学习维度 阶段1 · 第4章 常用 API 与集合入门 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

4.5 泛型:给集合贴上标签

审校 2026-09-26 · 素材来源:Java核心总结-cxuan(底稿改写)
📑 本篇章节导航 (共16节,点击直达)
标签贴上,两类问题消失三种贴法:类、接口、方法真相:泛型只活在编译期通配符:? extends 与 ? super标签字母的潜规则泛型的日常:BaseDao 一个类伺候所有表有界类型参数:给标签加门槛擦除的补偿:把 Class 传进来数组和泛型不对付PECS 在框架里长什么样三分钟自测一个迷你例子:泛型缓存擦除是历史的选择用泛型重构一段裸奔代码踩坑清单一句话总结

没有泛型的年代,List 里什么都能塞:存进去一个 String、取出来强转 Integer——编译没事,运行 ClassCastException 直接炸。泛型就是给容器贴标签:这箱只装 String,装错当场编译报错。

标签贴上,两类问题消失


List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123);        // 编译报错!标签说了只装 String

String s = list.get(0);  // 取出不用强转,类型天然是对的

红利两条:错误提前到编译期(改代码一分钟能修,线上炸一晚上);取出免强转(代码干净还安全)。

三种贴法:类、接口、方法


// ① 泛型类:容器自己带标签位
class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

// ② 泛型接口:实现时补标签(ArrayList<E> 实现的 List<E> 就是它)
interface Repo<T> {
    void save(T entity);
}

// ③ 泛型方法:调用时现场定类型,static 方法只能用这种
static <T> T first(List<T> list) {
    return list.get(0);
}

Box<String> b = new Box<>();     // 菱形语法:右边尖括号可以留空
Integer n = first(List.of(1, 2, 3));   // T 被推断为 Integer

注意第三种:static 方法拿不到类的 T(T 属于对象,static 属于类),要用自己的 <T> 声明。

真相:泛型只活在编译期

JDK 的泛型是类型擦除(Type Erasure):编译检查完,运行时把 T 换回 Object,标签被撕掉。证据一抓一把:


List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
a.getClass() == b.getClass();    // true!运行时都是同一个 ArrayList

擦除带来几条「为什么不行」:

通配符:? extends 与 ? super

方法的参数要接收「任意元素类型的 List」怎么办?List<Object> 接不了 List<String>(泛型没有继承传递),得用通配符:


void printAll(List<?> list) {                    // 任意元素类型
    for (Object o : list) System.out.println(o);
}

void readNumbers(List<? extends Number> list) {  // 上界:Number 或其子类
    Number n = list.get(0);      // 读出来当 Number,安全
    // list.add(1);              // 编译报错!不知道具体类型,不敢让你写
}

void fillInts(List<? super Integer> list) {      // 下界:Integer 或其父类
    list.add(1);                 // 写 Integer 安全:装进父类容器没问题
    // Integer x = list.get(0);  // 编译报错!读出来只敢保证是 Object
}

规律:extends 只读不写,super 只写不读。口诀 PECS(Producer Extends, Consumer Super):参数是生产者(给你数据)用 extends,是消费者(收你数据)用 super。Collections.copy 的签名就是这么写的,见一次记一次。

标签字母的潜规则

T(Type)泛类型、E(Element)集合元素、K/V(Key/Value)键和值、R(Result)返回值。字母其实随便起,但这些约定俗成的写法让代码自解释:看到 Map<K, V> 立刻知道一个当键一个当值,写成 Map<A, B> 读者就得猜。约定即文档,跟着大众走。

泛型的日常:BaseDao 一个类伺候所有表

业务里泛型最实战的用法是「通用仓库」。每张表都有增删改查,为 User、Order 各写一遍太蠢,写个泛型基类把公共逻辑收进去:


abstract class BaseDao<T> {
    abstract T findById(long id);
    void save(T entity) { /* 公共插入逻辑 */ }
    void deleteById(long id) { /* 公共删除逻辑 */ }
}

class UserDao extends BaseDao<User> { }
class OrderDao extends BaseDao<Order> { }

MyBatis-Plus 的 BaseMapper、Spring Data 的 JpaRepository 全是这一招:一个泛型接口,千万个实体类复用。看懂本篇,你就看懂了这些框架一半的设计。

有界类型参数:给标签加门槛

泛型参数能加限制:<T extends Comparable<T>> 意思是「T 必须可比较」。写通用最大值方法时不限定,T 之间没法比,编译器直接拦下:


static <T extends Comparable<T>> T max(List<T> list) {
    T champion = list.get(0);
    for (T t : list)
        if (t.compareTo(champion) > 0) champion = t;
    return champion;
}

extends 在这里读作「是其子类或本身」。方法签名把「我需要什么能力」亮出来——和 3.3 的接口合同一个思想:拿能力当门槛,门槛之内随便来。

擦除的补偿:把 Class 传进来

擦除让运行时认不出 T,惯用的补偿是把 Class<T> 当参数传进去:


static <T> T fromJson(String json, Class<T> clazz) { /* 反射造对象 */ }

User u = fromJson(s, User.class);

JSON 工具、ORM 框架清一色这个签名:你用 User.class 告诉它造谁,它反射造完再当 T 还给你。以后见到「方法参数尾巴上挂着 Class」,一秒反应过来:这是在给类型擦除打补丁。

数组和泛型不对付

new T[10] 非法之外,new List<String>[10] 也非法——泛型数组是禁区。根源还是擦除:数组运行时记得自己的元素类型,泛型运行时忘了,两边记忆对不上就钻出类型漏洞。JDK 自己的 ArrayList 内部也是拿 Object[] 装、取出时强转,硬绕开这个雷。知道这段恩怨,以后看集合源码就不会迷糊。

PECS 在框架里长什么样

Collections.copy 的签名 copy(List<? super T> dest, List<? extends T> src) 是 PECS 的标准示范:src 是生产者,供你读,用 extends;dest 是消费者,收你写,用 super。自己写工具方法拿不准,翻这个签名照着抄结构。日常业务确实少手写通配符,但读框架源码、看 API 文档时满眼都是——认识它,是看懂别人代码的门票。

三分钟自测

不看上文答三题:为什么 List<int> 非法而 List<Integer> 合法?为什么 static 方法不能用类上的 T?为什么 List<Object> 接不住 List<String>?全答得出,本篇就成了。第三题最常考:泛型之间没有继承传递,List<String> 不是 List<Object> 的子类型——想两头都接,用 List<?>。

一个迷你例子:泛型缓存

两个类型参数各管一摊的最小示范:


class LocalCache<K, V> {
    private final Map<K, V> map = new ConcurrentHashMap<>();

    V get(K key) { return map.get(key); }
    void put(K key, V v) { map.put(key, v); }
}

key 一个标签、value 一个标签,声明时一次定死。这个双字母结构就是 Map 的迷你复刻——学完本篇你已经有能力看懂「Map 是怎么被造出来」的骨架。真实项目里换成 Caffeine、Guava Cache,或方法上挂 @Cacheable 注解,内核还是这对 K/V。

擦除是历史的选择

为什么 Java 的泛型要擦除?为了兼容。JDK 5 引入泛型时,市面上已有海量无泛型的类库,擦除让新老代码跑在同一个运行时里,代价是运行时丢类型信息。对照组:C# 的泛型运行时真实存在;跑在 JVM 上的 Kotlin 用编译期技巧保住了部分信息。Java 的取舍是「平滑升级换功能阉割」。被问泛型原理时,答出擦除机制再带一句这段历史背景,就是加分项。

用泛型重构一段裸奔代码

想象没有标签的老代码:List 装着 Object,取出来一行 (String) list.get(i),循环里强转排成队。改造三步走:声明处加 <String>;new 的地方用菱形语法;删掉全部强转。改完编译,编译器立刻把藏着的类型错误全翻出来——红色波浪线标在哪,历史 bug 就埋在哪。这是泛型最实用的日常价值:让编译器替你翻旧账,比人肉 code review 眼尖得多。

踩坑清单

一句话总结

泛型是只在编译期存在的类型标签:贴上后装错当场报错、取出免强转;运行时标签被擦除,所以 new 不了 T、也认不出 List<String>——通配符 extends 只读、super 只写(PECS)。