玩王者的都知道，想玩好一个英雄，光看技能描述没用
得去练习场把细节磨透：技能释放距离多远？连招顺序怎么衔接？被动触发有什么隐藏机制？
练透了，实战才能行云流水不坑队友。
我们今天讲的泛型也同理，表面看起来简单，不少人上手就用，结果踩了一堆坑。
- 往 List 里塞了串 123，取出来想转成 Integer，啪！ClassCastException 直接崩给你看；
- 写代码时被String、Integer这些类型转换缠得头疼，逻辑明明简单，代码却冗余到像没练过的连招一样
敲黑板，咱目标是巅峰王者，需要扣细节！
今天这篇，就像带你在「英雄练习场」从头到尾吃透这个「英雄」：
-
为什么需要泛型？
-
泛型的基本使用，如 泛型类，泛型接口，泛型方法，还有上限和下限
-
泛型的类型擦除
为什么需要泛型？
在泛型出现前，Java 里的集合（比如ArrayList）只能存Object类型。这就像刚开始玩游戏没概念，法师出物理装，射手能买法术书 —— 辛辛苦苦存的金币却没用在刀刃上：
-
类型不安全：你可以往List里塞String、Integer、甚至自定义对象，编译器不管，但运行时强转就可能报ClassCastException（就像团战发现妲己带了破军，技能伤害零提升）；
-
代码冗余：每次从集合取元素都要手动强转，比如(String) list.get(0)，写多了又累又容易错。
泛型的出现，本质是给 Java 加了一套 类型过滤器：
-
编译期就检查 存入的类型对不对，提前拦住错误；
-
取元素时自动完成类型转换，不用手动写强转代码。
泛型的基本使用：就像给容器贴 “标签”
泛型的核心是 “类型参数”—— 给类、接口、方法贴个 “标签”，告诉它们 “只能处理这种类型”。
用法很简单，看这几个场景~~
泛型类：定制化的 “专属容器”
泛型类就是 带标签的容器，声明时用（T 是类型参数，可自定义~）标记，后续字段、方法都只能用这个类型。
比如我们定义一个 只能存字符串的盒子：
@Data
public class Box<T> {
private T content; // 字段类型为T
}
public class GenericMain {
public static void main(String[] args) {
// 使用时，指定标签为String（只能装字符串）
Box<String> box = new Box<>();
box.setContent("hello world");
box.setContent(123); // 报错：不能存整数
}
}
就像给盒子贴了 仅放文件 的标签，放别的东西就会被拦下 —— 泛型类通过类型参数，从源头保证类型一致
泛型接口：约定 输入输出类型
泛型接口和泛型类类似，声明时用类型参数约定 实现类必须处理的类型。比如定义一个 数据转换器 接口（真实可能更复杂，示例先简单点）
/**
* @desc 泛型接口：把T类型转换成R类型
* @author DonaldCen
* @date 2025/11/7 11:13
*/
public interface Converter<T, R> {
R convert(T input);
}
/**
* @author DonaldCen
* @desc 把String转换成Integer
* @date 2025/11/7 11:14
*/
public class StringToIntConverter implements Converter<String, Integer> {
@Override
public Integer convert(String input) {
return Integer.parseInt(input);
}
}
实现类必须明确 转换前是什么类型，转换后是什么类型，就像约定 只能把石榴转换成石榴汁，不能乱转成别的 —— 保证逻辑一致性。
泛型方法：不挑类型的 “通用工具”
泛型方法是 “独立的通用工具”，和类是否泛型无关，只需在方法返回值前加声明类型参数。比如写一个 “交换数组元素” 的工具：
/**
* @desc ArrayTool
* @author DonaldCen
* @date 2025/11/7 11:18
*/
public class ArrayTool {
// 泛型方法：交换任意类型数组的两个元素
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
String[] strArr = {"a", "b"};
swap(strArr, 0, 1); // 交换字符串数组，自动识别T为String
Integer[] nums = {1, 2};
swap(nums, 0, 1); // 交换整数数组，自动识别T为Integer
}
}
不管是字符串、整数还是自定义对象数组，这个方法都能直接用 —— 泛型方法的 “通用性” 就体现在这。
类型上下限：给类型参数 “划范围”
有时我们需要限制类型参数的范围（比如只能是某个类的子类），这就需要 “上下限”：
上限（extends）
上限（extends）：T extends A 表示 T 必须是 A 或其子类。
比如写一个 计算数字总和 的方法，只能接收数字类型（Integer、Double等，都是Number的子类）
// T必须是Number的子类（保证能调用doubleValue()方法）
public static <T extends Number> double sum(List<T> numbers) {
double total = 0;
for (T num : numbers) {
total += num.doubleValue(); // 安全调用Number的方法
}
return total;
}
下限（super）
下限（super）：T super B 表示 T 必须是 B 或其父类。
比如写一个 往集合里加整数 的方法，集合类型必须是Integer的父类（比如Number、Object）：
// 原代码：泛型下限方法
public static void addInt(List<? super Integer> list) {
list.add(100); // 正确：向T（Integer的父类）的集合中添加Integer
}
上下限就像给类型参数 “画了个圈”，既保证灵活性，又避免类型混乱。
为什么说 Java 泛型是 “伪泛型”？
面试常考：“Java 泛型和 C# 泛型有什么区别？” 核心答案是：Java 泛型是 “伪泛型”，因为它靠类型擦除实现 —— 编译后泛型信息会被擦掉，运行时不存在。
类型擦除：编译时 “擦掉” 类型参数
编译器处理泛型时，会做一件事：把类型参数替换成 “原始类型”（Raw Type）：
- 若没指定上限（比如T），替换成Object；
- 若有上限（比如T extends Number），替换成上限类型（Number）。
@Data
public class NumBox<T extends Number>{
private T val;
}
// 编译后会被擦除成
class NumBox { // 泛型参数T被擦掉
private Number val; // T换成上限Number
// ... Getter Setter
}
就像你给盒子贴的 “仅放数字” 标签，编译后标签被撕了，盒子本身只知道 “放的是 Number”—— 运行时没法区分是Integer还是Double。
怎么证明 “类型擦除”？
不同泛型实例，运行时类型相同：
public class GenericMain {
public static void main(String[] args) {
Box<String> strBox = new Box<>();
Box<Integer> intBox = new Box<>();
// 输出true：因为擦除后都是Box类型
System.out.println(strBox.getClass() == intBox.getClass());
}
}
结果：
true
不能用instanceof判断泛型类型
List<String> list = new ArrayList<>();
if (list instanceof List<String>) { // 编译报错
}
泛型多态与桥接方法
类型擦除可能导致 “子类重写父类方法时签名不匹配”，这时编译器会自动生成桥接方法来修复
// 父类：泛型类
class Parent<T> {
public T get() { return null; }
}
// 子类：指定T为String
class Child extends Parent<String> {
@Override
public String get() { return "hello"; }
}
擦除后，父类的get()变成public Object get()，而子类的get()是public String get()—— 方法签名不同，本不算重写
编译器会给子类加个桥接方法
// 自动生成的桥接方法
public Object get() {
return get(); // 调用子类的String get()
}
这样，当用Parent引用调用get()时，会通过桥接方法找到子类的实现，保证多态正确。
泛型的那些 “限制”，全因类型擦除
- 基础类型不能当泛型参数:因为擦除后泛型参数会换成Object，而int是基础类型，不能直接转Object（需要装箱）
- 不能实例化泛型类型:
-
- 不能new T()，因为擦除后T变成Object或上限类型，编译器不知道具体要创建哪个类的对象。
- 解决办法：用反射传入Class
public <T> T create(Class<T> clazz) throws Exception {
return clazz.newInstance(); // 反射创建实例
}
- 静态成员不能用泛型类的参数:
-
- 泛型类的静态变量 / 方法不能用T
- 因为静态成员属于类本身，而T是实例化时才确定的（不同实例的T可能不同）。若静态方法需要泛型，自己声明类型参数
class StaticDemo<T> {
static T value; // 报错：静态变量不能用T
// 正确：静态泛型方法，自己声明S
static <S> S get(S s) { return s; }
}
- 异常不能用泛型:
-
- 不能声明class MyException extends Exception，因为异常处理依赖运行时类型，而泛型擦除后无法区分不同泛型异常
如何获取泛型参数类型
泛型擦除后，一般情况下类型参数会消失，但如果子类继承泛型父类时指定了具体类型，这个信息会保留在字节码中，可通过反射获取。
// 父类：泛型类
class Base<T> {}
// 子类：明确指定T为String
class Sub extends Base<String> {}
// 反射获取父类的泛型参数
public class Test {
public static void main(String[] args) {
// 获取父类的泛型信息
ParameterizedType type = (ParameterizedType) Sub.class.getGenericSuperclass();
// 取出实际类型参数（这里是String）
Class<?> actualType = (Class<?>) type.getActualTypeArguments()[0];
System.out.println(actualType); // 输出：class java.lang.String
}
}
练完王者英雄的细节，进实战才能乱杀；吃透泛型的门道，写代码才能稳如老狗。
其实泛型这东西，说难也难
-
类型擦除、桥接方法这些底层逻辑，确实像英雄的隐藏机制，不掰开揉碎了看，容易一知半解；
-
但说简单也简单，核心无非是 “给代码加层类型保险”，让编译器帮你堵上那些 “放错技能” 的漏洞。
今天这篇从基础用法到底层原理，把泛型的 “技能连招”“机制细节”“实战坑点” 全捋了一遍。
下次写代码再遇到泛型，不妨想想王者练习场里的操作：
用泛型类就像选对英雄定位，
定上下限就像卡准技能范围，
避开基础类型坑就像记得别给法师出物理装
练熟了，自然顺手。
最后说句实在的：Java 里的这些 “基础机制”，就像王者里的补刀、走位，看着不起眼，实则决定了代码的上限。
把泛型吃透，不仅面试能多几分底气，写出来的代码也会少些 “bug 隐患”。
下次写代码时不妨试试今天说的技巧，遇到新坑也欢迎回来翻这篇 “练习手册”。
如果有自己的泛型踩坑故事，评论区分享一下，说不定能帮到更多刚入门的小伙伴～
咱们下篇技术干货见～
