目录
[1. 无界通配符](#1. 无界通配符)
[2. 上界通配符](#2. 上界通配符)
[3. 下界通配符](#3. 下界通配符)
[4. 三种通配符对比](#4. 三种通配符对比)
[七、为什么 List 不能赋值给 List](#七、为什么 List 不能赋值给 List)
[1. 不能直接 new T()](#1. 不能直接 new T())
[2. 不能直接创建泛型类型参数数组](#2. 不能直接创建泛型类型参数数组)
[3. 不能通过 instanceof 判断具体泛型参数](#3. 不能通过 instanceof 判断具体泛型参数)
[4. 静态成员不能直接使用类级别的泛型参数](#4. 静态成员不能直接使用类级别的泛型参数)

一、泛型
泛型 就是把类型参数化,在定义类、接口或方法时,不提前写死具体的数据类型,而是在使用时指定。
例如,以前创建一个集合:
java
ArrayList list = new ArrayList();
list.add("Java");
list.add(123);
list.add(true);
由于没有指定类型,什么数据都可以添加,取出来时还需要类型转换,容易出现 ClassCastException。
使用泛型:
java
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
// list.add(123); // 编译报错
<String> 限定了集合中的元素类型,编译器会帮我们检查。
泛型主要解决三个问题:
-
类型安全:编译阶段发现类型错误。
-
减少类型转换:取出数据时不需要频繁强制转换。
-
提高复用性:一套代码可以适用于不同的数据类型。
二、泛型类
泛型类就是在定义类时声明类型参数。
基本格式:
java
public class 类名<T> {
// T 代表某种类型
}
这里的 T 不是固定的类型,而是一个类型占位符。
例如自己定义一个容器:
java
class Box<T> {
private T data;
public void setData(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
使用时指定具体类型:
java
Box<String> box1 = new Box<>();
box1.setData("Java");
String str = box1.getData();
Box<Integer> box2 = new Box<>();
box2.setData(100);
Integer num = box2.getData();
同一个 Box 类,既能存字符串,也能存整数,不需要为每种类型重新写一个类。
常见泛型标识:
| 标识 | 常见含义 |
|---|---|
T |
Type,类型 |
E |
Element,元素 |
K |
Key,键 |
V |
Value,值 |
R |
Result,结果 |
这些只是命名习惯,并不是 Java 关键字。
泛型也可以有多个类型参数:
java
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
}
使用:
java
Pair<String, Integer> pair =
new Pair<>("age", 25);
三、泛型方法
泛型方法是在方法上单独声明泛型,它不要求所在的类本身是泛型类。
基本格式:
修饰符 <T> 返回值类型 方法名(参数列表)
注意:方法自己的 **
例如:
java
public class GenericDemo {
public static <T> void print(T value) {
System.out.println(value);
}
public static void main(String[] args) {
print("Java");
print(123);
print(true);
}
}
这里 print() 可以接收不同类型的数据,编译器通常会根据传入的参数自动推断类型。
再看一个带返回值的泛型方法:
java
public static <T> T getFirst(List<T> list) {
return list.get(0);
}
调用:
java
List<String> names = Arrays.asList("张三", "李四");
String name = getFirst(names);
System.out.println(name); // 张三
这个方法可以适用于 List<String>、List<Integer> 等不同类型的集合。
注意:这里要求列表非空,否则 get(0) 会抛出异常。
泛型类和泛型方法的区别:
| 对比 | 泛型类 | 泛型方法 |
|---|---|---|
| 声明位置 | 类名后面 | 方法返回值类型前面 |
| 作用范围 | 类中可以使用 | 主要在该方法内使用 |
| 类型确定 | 创建或使用对象时 | 调用方法时通常可以推断 |
| 是否依赖泛型类 | 本身就是泛型类 | 不需要 |
还有个容易弄混的地方:泛型类中的普通方法使用类级别的 T,并不代表它自己声明了泛型。
java
class Box<T> {
// 使用类级别的 T
public void set(T value) {
}
// 这是独立的泛型方法
public <E> void print(E value) {
System.out.println(value);
}
}
四、泛型接口
泛型接口和泛型类基本一样,只不过定义在接口上。
java
interface Converter<T, R> {
R convert(T value);
}
这里有两个类型参数:
-
T:输入类型 -
R:返回类型
实现方式一:实现接口时指定具体类型。
java
class StringToInteger implements Converter<String, Integer> {
@Override
public Integer convert(String value) {
return Integer.parseInt(value);
}
}
使用:
java
Converter<String, Integer> converter =
new StringToInteger();
System.out.println(converter.convert("123")); // 123
实现方式二:实现类继续保留泛型。
java
class DefaultConverter<T> implements Converter<T, T> {
@Override
public T convert(T value) {
return value;
}
}
这样实现类依然可以适用于不同的数据类型。
实际开发中,泛型接口非常常见,例如:
java
List<String>
Map<String, Integer>
Comparator<User>
其中 List、Map、Comparator 本身都是泛型接口。
五、泛型通配符
这部分比较容易混淆,重点理解三个写法:
-
<?> -
<? extends T> -
<? super T>
先看一个问题。
假设有两个集合:
java
List<String> names = new ArrayList<>();
List<Integer> numbers = new ArrayList<>();
如果想写一个方法,既可以接收字符串列表,也可以接收整数列表,应该怎么写?
1. 无界通配符 <?>
java
public static void printList(List<?> list) {
for (Object obj : list) {
System.out.println(obj);
}
}
调用:
java
printList(names);
printList(numbers);
<?> 表示元素类型未知,因此可以接收不同元素类型的列表。
但是要注意:
List<?> list = new ArrayList<String>();
// list.add("Java"); // 编译报错
因为编译器不知道集合实际允许添加什么类型。
可以读取元素,但通常只能作为 Object 使用;不能直接添加非 null 元素。
2. 上界通配符 <? extends T>
表示元素类型必须是 T 或者 T 的子类型。
例如:
java
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
定义方法:
java
public static void printAnimals(
List<? extends Animal> animals) {
for (Animal animal : animals) {
System.out.println(animal);
}
}
调用:
java
List<Dog> dogs = new ArrayList<>();
List<Cat> cats = new ArrayList<>();
printAnimals(dogs);
printAnimals(cats);
这里可以读取元素并当作 Animal 处理。
但是不能直接添加:
java
public static void test(List<? extends Animal> list) {
// list.add(new Dog()); // 编译报错
}
为什么?
因为传入的可能是 List<Cat>,如果允许添加 Dog,就会破坏集合原来的类型约束。
所以:
**<? extends T>**适合从集合中读取 T 类型的数据。
3. 下界通配符 <? super T>
表示元素类型是 T 或者 T 的父类型。
java
public static void addDogs(List<? super Dog> list) {
list.add(new Dog());
}
可以传入:
java
List<Dog> dogs = new ArrayList<>();
List<Animal> animals = new ArrayList<>();
List<Object> objects = new ArrayList<>();
addDogs(dogs);
addDogs(animals);
addDogs(objects);
因为这些集合都可以安全地接收 Dog 对象。
但从这种集合中读取时,编译器只能保证元素是 Object:
Object obj = objects.get(0);
**<? super T>**适合向集合中写入 T 类型及其子类型的数据。
4. 三种通配符对比
| 通配符 | 含义 | 读取 | 添加 |
|---|---|---|---|
<?> |
任意未知类型 | Object | 通常不能 |
<? extends T> |
T 或 T 的子类型 | 可以作为 T 读取 | 通常不能 |
<? super T> |
T 或 T 的父类型 | 只能保证 Object | 可以添加 T 及子类型 |
这里有个常用原则:PECS。
-
Producer Extends :主要用于提供数据,使用
extends。 -
Consumer Super :主要用于接收数据,使用
super。
也可以直接理解为:主要读数据用 extends,主要写数据用 super。
六、泛型的类型限定
除了通配符,定义泛型时也可以限定类型范围。
例如:
java
public static <T extends Number> void printNumber(T value) {
System.out.println(value);
}
调用:
java
printNumber(100);
printNumber(3.14);
// printNumber("Java"); // 编译报错
这里的 <T extends Number> 表示 T 必须是 Number 或其子类。
如果需要多个上界,可以使用 &:
<T extends Number & Comparable<T>>
注意:这里的 extends 同样适用于接口约束,不仅仅代表继承类。
另外,泛型类型参数只能使用引用类型,不能使用基本数据类型:
java
List<Integer> list = new ArrayList<>();
// List<int> list2; // 编译报错
七、为什么 List<String> 不能赋值给 List<Object>?
这是 Java 泛型比较容易踩坑的地方。
java
List<String> names = new ArrayList<>();
// List<Object> objects = names; // 编译报错
虽然 String 是 Object 的子类,但是:
**List
原因也很简单。
假如允许这样赋值:
java
List<Object> objects = names;
objects.add(123);
那原本只允许存储字符串的集合,就被添加了整数,类型约束也就失效了。
这种特性叫做泛型的不变性(Invariance)。
如果只是想接收不同类型的集合,可以使用:
List<?> list = names;
如果需要读取某个父类型及其子类型的数据,可以使用:
List<? extends Object> list = names;
不过这里 List<? extends Object> 与 List<?> 在实际使用上基本等价,通常直接写 List<?> 更简单。
八、泛型擦除
Java 泛型主要在编译阶段起作用。
编译器会进行类型检查,生成字节码时,泛型类型参数通常会被擦除为其上界;没有显式上界的类型参数,通常擦除为 Object。
例如:
java
List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
运行时:
java
System.out.println(
list1.getClass() == list2.getClass()
); // true
因为它们运行时的实际类都是 ArrayList。
这就是 Java 的类型擦除(Type Erasure)。
因此会有一些限制。
1. 不能直接 new T()
java
class Box<T> {
// T obj = new T(); // 编译报错
}
因为运行时无法确定 T 对应的具体类型。
2. 不能直接创建泛型类型参数数组
java
class Box<T> {
// T[] arr = new T[10]; // 编译报错
}
3. 不能通过 instanceof 判断具体泛型参数
java
List<String> list = new ArrayList<>();
// list instanceof List<String> // 编译报错
System.out.println(list instanceof List<?>); // true
4. 静态成员不能直接使用类级别的泛型参数
java
class Box<T> {
// private static T data; // 编译报错
}
因为静态成员属于类,而类级别的 T 通常要在具体使用泛型类时才能确定。
如果静态方法需要泛型,可以单独声明:
java
public static <T> void print(T value) {
System.out.println(value);
}
需要补充一点:类型擦除不代表泛型信息完全消失,类或方法声明中的部分泛型信息仍然可以通过反射获取。
九、实际开发中使用泛型
后端开发经常需要返回不同类型的数据。
例如,用户接口返回用户信息,订单接口返回订单信息。
如果每一种数据都定义一个单独的响应类,会产生很多重复代码。
可以使用泛型封装统一响应结果。
java
public class Result<T> {
private int code;
private String message;
private T data;
public Result(int code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
public T getData() {
return data;
}
}
假设有一个用户类:
java
class User {
private String name;
public User(String name) {
this.name = name;
}
}
返回单个用户:
java
Result<User> result =
new Result<>(200, "success", new User("张三"));
返回用户列表:
java
List<User> users = new ArrayList<>();
users.add(new User("张三"));
users.add(new User("李四"));
Result<List<User>> result =
new Result<>(200, "success", users);
这里的:
java
Result<User>
Result<List<User>>
都是在使用同一个泛型类,只是内部的数据类型不同。
十、常用知识点速查
| 知识点 | 写法 | 作用 |
|---|---|---|
| 泛型类 | class Box<T> |
类级别的类型参数 |
| 泛型方法 | <T> T get(...) |
方法级别的类型参数 |
| 泛型接口 | interface Converter<T> |
接口级别的类型参数 |
| 无界通配符 | <?> |
接收未知元素类型 |
| 上界通配符 | <? extends T> |
接收 T 或子类型,适合读取 |
| 下界通配符 | <? super T> |
接收 T 或父类型,适合写入 |
| 类型限定 | <T extends Number> |
约束泛型类型范围 |
| 类型擦除 | Type Erasure | 泛型的主要运行时实现机制 |
| 类型推断 | new ArrayList<>() |
编译器推断类型参数 |
重点:
-
T、E、K、V只是类型参数名称。 -
泛型类、泛型接口在声明时定义类型参数。
-
泛型方法需要单独声明自己的类型参数。
-
extends主要用于安全读取,super主要用于安全写入。 -
List<String>不能直接赋值给List<Object>。 -
Java 泛型采用类型擦除,存在一些运行时限制。