泛型

1 泛型类的定义

1.1 语法

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

• E 表示 Element
• K 表示 Key
• V 表示 Value
• N 表示 Number
• T 表示 Type
• S, U, V 等等 - 第二、第三、第四个类型

1.2 简单示例

定义一个泛型类顺序表

// 演示泛型目的，没有做错误处理和扩容
public class MyArrayList<E> {
private E[] array;
private int size;
public MyArrayList() {
// 泛型类型无法直接创建数组，具体的见下面的注意事项
array = (E[])new Object[16];
size = 0;
}
// 尾插
public void add(E e) {
array[size++] = e;
}
// 尾删
public E remove() {
E element = array[size - 1];
array[size - 1] = null; // 将容器置空，保证对象被正确释放
size--;
return element;
}
}

1.3 加入静态内部类的示例

定义一个泛型类链表

public class MyLinkedList<E> {
public static class Node<E> {
private E value;
private Node<E> next;
private Node(E e) {
value = e;
next = null;
}
}
private Node<E> head;
private int size;
public MyLinkedList() {
head = null;
size = 0;
}
// 头插
public void pushFront(E e) {
Node<E> node = new Node<>(e);
node.next = head;
head = node;
size++;
}
// 尾插
public void pushBack(E e) {
if (size == 0) {
pushFront(e);
return;
}
Node<E> cur = head;
while (cur.next != null) {
cur = cur.next;
}
cur.next = new Node<E>(e);
size++;
}
}

2 泛型类的使用

2.1 语法

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

2.2 示例

MyArrayList<String> list = new MyArrayList<String>();

2.3 类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArrayList<String> list = new MyArrayList<>(); // 可以推导出实例化需要的类型实参为 String

3 泛型类的定义-类型边界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

3.1 语法

class 泛型类名称<类型形参 extends 类型边界> {
      ...
}

3.2 示例

public class MyArrayList<E extends Number> {
      ...
}

只接受 Number 的子类型作为 E 的类型实参

MyArrayList<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArrayList<String> l2; // 编译错误，因为 String 不是 Number 的子类型

error: type argument String is not within bounds of type-variable E
MyArrayList<String> l2;
^
where E is a type-variable:
E extends Number declared in class MyArrayList

没有指定类型边界 E，可以视为 E extends Object

4 类型擦除

我们之前已经讲过，泛型是作用在编译期间的一种机制，实际上运行期间是没有这么多类的，那运行期间是什么类型呢？这里就是类型擦除在做的事情。

class MyArrayList<E> {
// E 会被擦除为 Object
}
class MyArrayList<E extends Comparable<E>> {
// E 被擦除为 Comprable
}

了解： 编译器在类型擦除阶段在做什么？

1. 将类型变量擦除为指定类型，即 Object 或者 Comparable
2. 加入必要的类型转换语句
3. 加入必要的 bridge method 保证多态的正确性

5 泛型类的使用-通配符(Wildcards)

5.1 基本

? 用于在泛型的使用，即为通配符

示例：

public class MyArrayList<E> {...}
// 可以传入任意类型的 MyArrayList
public static void printAll(MyArrayList<?> list) {
...
}
// 以下调用都是正确的
printAll(new MyArrayList<String>());
printAll(new MyArrayList<Integer>());
printAll(new MyArrayList<Double>());
printAll(new MyArrayList<Number>());
printAll(new MyArrayList<Object>());

5.2 通配符-上界

语法

<? extends 上界>

示例

// 可以传入类型实参是 Number 子类的任意类型的 MyArrayList
public static void printAll(MyArrayList<? extends Number> list) {
...
}
// 以下调用都是正确的
printAll(new MyArrayList<Integer>());
printAll(new MyArrayList<Double>());
printAll(new MyArrayList<Number>());
// 以下调用是编译错误的
printAll(new MyArrayList<String>());
printAll(new MyArrayList<Object>());

注意： 需要区分 泛型使用中的通配符上界 和 泛型定义中的类型上界

5.3 通配符-下界

语法

<? extends 下界>

示例

// 可以传入类型实参是 Integer 父类的任意类型的 MyArrayList
public static void printAll(MyArrayList<? super Integer> list) {
...
}
// 以下调用都是正确的
printAll(new MyArrayList<Integer>());
printAll(new MyArrayList<Number>());
printAll(new MyArrayList<Object>());
// 以下调用是编译错误的
printAll(new MyArrayList<String>());
printAll(new MyArrayList<Double>());

6 泛型中的父子类型（重要）

public class MyArrayList<E> { ... }
// MyArrayList<Object> 不是 MyArrayList<Number> 的父类型
// MyArrayList<Number> 也不是 MyArrayList<Integer> 的父类型
// 需要使用通配符来确定父子类型
// MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
// MyArrayList<? extends Number> 是 MyArrayList<Integer> 的父类型

7 泛型方法

7.1 定义语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

7.2 示例

public class Util {
public static <E> void swap(E[] array, int i, int j) {
E t = array[i];
array[i] = array[j];
array[j] = t;
}
}

7.3 使用示例-可以类型推导

Integer[] a = { ... };
swap(a, 0, 9);
String[] b = { ... };
swap(b, 0 , 9);

7.4 使用示例-不使用类型推导

Integer[] a = { ... };
Util.<Integer>swap(a, 0, 9);
String[] b = { ... };
Util.<String>swap(b, 0, 9);

8 泛型的限制

1. 泛型类型参数不支持基本数据类型
2. 无法实例化泛型类型的对象
3. 无法使用泛型类型声明静态的属性
4. 无法使用 instanceof 判断带类型参数的泛型类型
5. 无法创建泛型类数组
6. 无法 create、catch、throw 一个泛型类异常（异常不支持泛型）
7. 泛型类型不是形参一部分，无法重载