彻底搞懂 Java 泛型：从基本原理到踩坑避坑全指南 从入门到精通，只差这篇

1、概述

泛型的概念：

泛型让类、接口或方法在定义时不指定具体类型，而在使用时再确定类型。

换句话说：泛型让代码在“写的时候”更通用，在“用的时候”更安全。

泛型的好处：类型安全、消除强制类型转换

2、泛型类

2.1 泛型类的定义

● 泛型类的定义语法：

class 类名称<泛型标识, 泛型标识, ...> {

private 泛型标识 变量名;

.....

}

● 常用的泛型标识：T、E、K、V...

泛型类定义举例：

package com.itheima.demo2;

/**

* 泛型类的定义

* @param 泛型标识——类型形参

* T 创建对象的时候指定具体的类型

*/

public class Generic {

private T key;

public Generic(T key) {

this.key = key;

}

public T getKey() {

return key;

}

public void setKey(T key) {

this.key = key;

}

}

2.2 泛型类的使用

● Java1.7以后，后面的<>中的具体的数据类型可以省略不写

类名<具体的数据类型> 对象名 = new 类名<>();

泛型类的使用举例：

Generic generic = new Generic<>("a");

2.3 泛型类的注意事项

①泛型类在创建对象的时候，没有指定类型，将按照Object类型来操作。

Generic generic = new Generic("ABC");

Object key3 = generic.getKey();

System.out.println("key3:" + key3);

②泛型类，不支持基本数据类型。

Generic generic1 = new Generic(100);

③泛型类虽然指定的类型是不同的，但本质上是同一个类型

System.out.println(intGeneric.getClass());

System.out.println(strGeneric.getClass());//他俩输出结果是一样的

2.4 从泛型类派生的子类

●子类也是泛型类的情况下，子类和父类的泛型类型要一致

class ChildGeneric extends Generic

●子类不是泛型类的情况下，父类要明确泛型的数据类型

class ChildGeneric extends Generic

举例说明 子类是泛型类：

//这是一个父类 是泛型类

public class Parent {

private E value;

public E getValue() {

return value;

}

public void setValue(E value) {

this.value = value;

}

}

//若此时定义了一个子类，要继承父类（标识为T），那它的泛型标识也一定是T，要不然报错

public class ChildFirst extends Parent {

@Override

public T getValue() {

return super.getValue();

}

}

举例说明子类不是泛型类：

//子类不是泛型类，父类是泛型类的话，不能写泛型类型，必须指定父类数据类型，否则报错

public class ChildSecond extends Parent {

@Override

public Integer getValue() {

return super.getValue();

}

@Override

public void setValue(Integer value)

3、泛型接口

3.1 泛型接口的定义

● 泛型接口的定义语法

interface 接口名称<泛型标识, 泛型标识, ...> {

泛型标识 方法名();

.....

}

3.2 泛型接口的使用

和前面的泛型类很类似

● 实现类不是泛型类的情况下，接口要明确数据类型

//这是一个泛型接口

public interface Generator {

T getKey();

}

//这不是一个泛型类，实现了泛型接口

public class Apple implements Generator {

@Override

public String getKey() {

return "hello generic";

}

}

● 实现类也是泛型类的情况下，实现类和接口的泛型类型要一致

//这是一个泛型接口

public interface Generator {

T getKey();

}

//这是一个泛型类，实现了泛型接口

public class Pair implements Generator {

@Override

public T getKey() {

return null;

}

}

4、泛型方法

泛型方法的定义：泛型方法，是在调用方法的时候指明泛型的具体类型

你可能会问，刚刚讲泛型类的时候不是已经包含了泛型方法吗？

那个其实是属于泛型类的成员方法，不是泛型方法！

泛型方法是我有泛型列表的，而泛型类的成员方法只在参数列表中有泛型标识

4.1 泛型方法

语法

修饰符 返回值类型 方法名(形参列表) {

方法体...

}

● public 与返回值中间的 非常重要，可以理解为声明此方法为泛型方法。只有声明了 的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。

举个例子

public class GenericMethodExample {

// 泛型方法：交换任意类型数组中两个元素的位置

public static void swap(T[] array, int i, int j) {

T temp = array[i];

array[i] = array[j];

array[j] = temp;

}

}

就是泛型列表，它告诉编译器：“我这个方法里有一个类型参数 T，可以在方法体中使用”。

后面的 T[] array 是使用这个类型参数。

我们也可以在泛型类中使用泛型方法，泛型方法的泛型标识独立于泛型类(即便是相同标识)

public class Box {

private T value;

public Box(T value) {

this.value = value;

}

// 泛型方法（与类的泛型参数 T 无关）

public void print(E element) {

System.out.println("打印内容：" + element);

}

}

这个方法在 void 前面又声明了一个新的类型参数 ；它与类的泛型参数 T 没有任何关系；

请注意，泛型类中的方法不能是 static，如果它要用类的泛型参数

但是泛型方法可以是 static的（泛型方法的类型参数是方法级别的，不依赖于类的泛型参数。）

4.2 泛型方法与可变参数

语法

public void print(E... e) {

for (E el : e) {

System.out.println(e);

}

}

举个例子

public static void print(E... e) {

for (int i = 0; i < e.length; i++) {

System.out.println(e[i]);

}

}

Box intBox = new Box<>();

Box strBox = new Box<>();

4.3 泛型方法的总结

泛型方法能使方法独立于类而产生变化

如果 static 方法要使用泛型能力，就必须使其成为泛型方法

5、类型通配符

类型通配符一般是使用“？”代替具体的类型实参。

所以，类型通配符是类型实参，而不是类型形参。

我来细细讲讲，这里很绕

这个T，是形参，是在定义过程中写的

class Box { // T 是类型形参

private T value;

public T getFirst() { return value; }

public void setFirst(T value) { this.value = value; }

}

当别人使用时，会传入“实参类型” 这里的 Integer、String 就是 类型实参，代替了 T。

Box intBox = new Box<>();

Box strBox = new Box<>();

这个< ？>是实参，实在使用过程中写的

public static void showBox(Box box)

这个< ？>仿佛在说“我接收一个 Box，但是我不知道它装的是什么类型”，? 是“实参中的未知者”。

5.1 类型通配符的引出

①我们定义了一个泛型类 叫Box

public class Box {

private E first;

public E getFirst() {

return first;

}

public void setFirst(E first) {

this.first = first;

}

}

②又定义了一个静态方法，用于展示box对象的属性

Number是数值类型的共同父类（抽象类）。

public static void showBox(Box box) {

Number first = box.getFirst();

System.out.println(first);

}

在这里，请注意！！

Box它可以装任何 Number 及其子类的对象（比如 Integer、Double）。

所以：我写如下代码没问题

Box box1 = new Box<>();

box1.setFirst(100);

showBox(box1);

但是写如下代码会出问题

Box box2 = new Box<>();

box2.setFirst(200);

showBox(box2);//这里会报错

为什么会报错？因为你往showBox中传递的参数是 Box 类型，但是showBox所需要的是Box类型！

那怎么办？用类型通配符

public static void showBox(Box box) {

Object first = box.getFirst();

System.out.println(first);

}

5.2 类型通配符的上限

定义：

类/接口

根据我们刚刚的例子，可以传递Box 也可以是Box类型，还可以是其他类型

但我们设置了类型通配符的上限后（比如上限是Number）：

public static void showBox(Box box) {

Number first = box.getFirst();

System.out.println(first);

}

代表着，我只可以接收Box的泛型是Number或其子类的对象

注意一点，我们不能在box中add元素，我举例说明：

我们有一个简单的继承结构：

class Animal {}

class Cat extends Animal {}

class MiniCat extends Cat {}

然后我们准备三种容器：

List animals = new ArrayList<>();

List cats = new ArrayList<>();

List miniCats = new ArrayList<>();

定义一个方法，能接收装各种“猫或猫的子类”的容器：

public static void readCats(List list) {

Cat c = list.get(0); // ✅ 可以安全读取为 Cat

// list.add(new Cat()); // ❌ 不行

// list.add(new MiniCat()); // ❌ 不行

System.out.println(c.getClass().getSimpleName());

}

为什么 add 不行？

假设你是这样调用方法的：readCats(miniCats);

那么 list 实际指向 List。list中的元素必须是MiniCat类型和其子类，

如果我写了add(new Cat())，那肯定不对，因为Cat不是MiniCat类型和其子类

所以编译器为了安全，干脆禁止任何 add（除了 null）。

但你可以 get，因为无论实际是哪种猫，它都至少是个 Cat。

5.3 类型通配符的下限（1）

定义

类/接口

注意一点，我们不能在box中get元素，但是add可以：

和上面一样，我们有一个简单的继承结构：

class Animal {}

class Cat extends Animal {}

class MiniCat extends Cat {}

然后我们准备三种容器：

List animals = new ArrayList<>();

List cats = new ArrayList<>();

List miniCats = new ArrayList<>();

定义一个方法，能接收装各种“猫或猫的父类”的容器：

public static void addCats(List list) {

list.add(new Cat()); // ✅ 可以

list.add(new MiniCat()); // ✅ 也可以

// Cat c = list.get(0); // ❌ 不行，只能当 Object

Object obj = list.get(0); // ✅ 只能读成 Object

}

为什么 add 可以？

假设传入的是：addCats(animals);

list 实际是 List ，所以list中必须是Animal或其子类，往 List 里加 Cat 或 MiniCat，当然安全。

但如果反过来你想 Cat c = list.get(0)，编译器拒绝：

——因为它不知道你传进来的是不是 List