前言

在上一篇文章中，给大家讲解了泛型的概念、作用、使用场景，以及泛型集合、泛型接口和泛型类的用法，但受限于篇幅，并没有把泛型的内容讲解完毕。所以今天我们会继续学习泛型方法、泛型擦除，以及通配符等的内容，希望大家继续做好学习的准备哦。

---

全文大约【4600】 字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考…

一. 泛型方法

1. 简介

我们可以在定义接口和类时使用泛型，这样该接口和类中的所有方法及成员变量等处，也都可以使用该泛型。但其实泛型可以应用在整个类上，也可以只应用在类中的某个方法上。也就是说，方法所在的类可以是泛型类，也可以不是泛型类。方法中是否带有泛型，与其所在的类有没有泛型没有关系。

泛型方法是在调用方法时才确定类型的方法，泛型可以使得该方法独立于类而产生变化。另外，static静态方法无法访问泛型类的类型参数，因此，如果想让一个static方法具有泛型能力，就必须使该静态方法成为泛型方法。

2. 语法

我们在定义泛型方法时，需要在方法名的前面添加类型参数。定义泛型方法的语法格式如下：

[访问权限修饰符] [static] [final] <类型参数列表> 返回值类型 方法名([形式参数列表])

例如：

public static <T> List showInfo(Class<T> clazz,int userId){}

一般情况下，我们编写泛型方法时，必须在该方法的名称前声明要使用的泛型，并且可以同时声明多个泛型，中间也是用逗号分割。接下来就定义一个泛型方法，给大家具体介绍一下泛型方法的创建和使用。

3. 代码案例

这里我们定义一个泛型方法，用于对数组排序后再遍历元素输出，代码如下：

import java.util.Arrays;public class Demo04 {//定义了一个静态的泛型方法，遍历数组中的每个元素public static <T> void printArray(T[] arr) {//先对数组进行排序Arrays.sort(arr);//再遍历数组元素for (T t : arr) {System.out.print(t + " ");}System.out.println();}public static void main(String[] args) {Integer[] nums= {100,39,8,200,65};//调用泛型方法printArray(nums);}
}

在上面的代码中，printArray()就是一个泛型方法，该方法中使用了类型参数T。并且我们在方法的参数中，使用类型参数T定义了一个泛型数组T[]，接着对该数组进行排序和遍历。这样以后无论我们传入任何类型的数组，都可以在不进行类型转换的前提下，轻松实现排序等功能了，这样我们之前提的需求也就很容易实现了。

二. 通配符

除了以上这些用法之外，泛型中还有一个很重要的通配符功能，接下来我们就来看看它是怎么回事。

1. 简介

泛型中的通配符其实也是一种特殊的泛型类型，也称为通配符类型参数。利用通配符类型参数，可以让我们编写出更通用的代码，甚至可以在不知道实际类型的情况下使用它们。我们一般是使用 ? 来代替具体的类型参数，例如 List<?> 在逻辑上可以等同于 List、List 等所有 List<具体类型实参> 的类。

对此，有的小伙伴可能会很好奇，我们为什么需要通配符呢？其实之所以会出现通配符，主要是在开发时，有时候我们需要一个泛型类型，但我们却不知道该使用哪个具体的类型。在这种情况下，我们就可以使用通配符类型参数，让代码更加地通用。比如，我们想编写一个可以接受任何类型的集合，并返回其中最大的元素时，此时我们可能并不确定到底该传入哪个具体的集合，那使用通配符就会更好一些。

2. 通配符的形式

泛型通配符在具体使用时，有如下三种实现形式：

• 未限定通配符(?) ： ?表示未知类型的通配符；
• 上限通配符(? extends T) ： ?表示类型上限的通配符，T是一个类或接口；
• 下限通配符(? super T) ： ?表示类型下限的通配符，T是一个类或接口。

接下来我们针对以上这三种形式，分别通过几个案例来给大家讲解其用法。

3. 未限定通配符(?)

未限定通配符(?)是一种表示未知类型的通配符，它可以在需要一个类型参数的情况下使用。但由于没有限制，因此它只能用于简单的情况，例如集合中的迭代器或者返回类型是泛型的方法等。下面是一个简单的例子：

import java.util.ArrayList;
import java.util.List;public class Demo05 {public static void main(String[] args) {List<String> names = new ArrayList<String>();List<Integer> ages = new ArrayList<Integer>();List<Number> numbers = new ArrayList<Number>();names.add("一一哥");names.add("秦始皇");ages.add(28);ages.add(50);ages.add(28);numbers.add(100);numbers.add(800);printElement(names);printElement(ages);printElement(numbers);}//未限定通配符的使用public static void printElement(List<?> data) {for(int i=0;i<data.size();i++) {//data.getClass().getSimpleName():用于获取某个类的类名System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));}}}

在这个例子中，printElement()方法就接受了一个未知类型的List集合，所以names，ages，numbers都可以作为这个方法的实参，这就是未限定通配符的作用。

4. PECS原则

PECS是Producer Extends Consumer Super的缩写，这是关于Java泛型的一种设计原则。该原则表示，如果我们需要返回T，它是生产者(Producer)，要使用extends通配符；如果需要写入T，它就是消费者(Consumer)，要使用super通配符。该原则可以指导我们在使用泛型时，该如何定义类型参数的上限和下限。

当我们使用泛型时，可能需要定义类型参数的上限和下限。

例如，我们想要编写一个方法来处理一些集合类型，但我们不知道这些集合中到底有什么类型的元素，此时我们就可以定义一个类型参数来处理所有的集合类型。一般我们可以利用extends来设置泛型上限，利用super来设置泛型下限。接下来会在下面的第5和第6小结中，给大家讲解泛型的上限和下限具体该如何实现，请大家继续往下学习。

5. 上限通配符(? extends T)

上限通配符(？extends T)是一种表示类型上限的通配符，其中T是一个类或接口，泛型类的类型必须实现或继承 T这个接口或类。它指定了可以使用的类型上限，主要是用于限制输入的参数类型。

import java.util.ArrayList;
import java.util.List;/*** @author 一一哥Sun */
public class Demo06 {public static void main(String[] args) {List<String> names = new ArrayList<String>();List<Integer> ages = new ArrayList<Integer>();List<Number> numbers = new ArrayList<Number>();names.add("一一哥");names.add("秦始皇");ages.add(28);ages.add(50);ages.add(28);numbers.add(100);numbers.add(800);//String等非Number类型就不行//printElementUpbound(names);//泛型值只能是Number及其子类类型,所以Integer/Double/Float等类型都可以，但String就不行printElementUpbound(ages);printElementUpbound(numbers);}//上限通配符的使用，这里的泛型值只能是Number及其子类类型public static void printElementUpbound(List<? extends Number> data) {for(int i=0;i<data.size();i++) {//data.getClass().getSimpleName():用于获取某个类的类名System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));}}
}

在这个例子中，printElementUpbound方法中的集合泛型，可以是Number类或其子类，除此之外的其他类型都不行。也就是说，我们只能使用Number或其子类作为类型参数，泛型类型的上限是Number，这就是上限通配符的含义。

6. 下限通配符(? super T)

下限通配符(？super T)是一种表示类型下限的通配符，其中T是一个类或接口。它指定了可以使用的类型下限，主要用于限制输出的参数类型。下面是一个简单的例子：

import java.util.ArrayList;
import java.util.List;public class Demo07 {public static void main(String[] args) {List<String> names = new ArrayList<String>();List<Integer> ages = new ArrayList<Integer>();List<Double> numbers = new ArrayList<Double>();names.add("一一哥");names.add("秦始皇");ages.add(28);ages.add(50);ages.add(28);numbers.add(100.0);numbers.add(800.9);//String等非Number类型就不行//printElementUpbound(names);//此时Double类型也不行//printElementDownbound(numbers);//泛型值只能是Integer及其父类类型,所以Double/Float/String等类型都不可以printElementDownbound(ages);}//下限通配符的使用，这里的泛型值只能是Integer及其父类类型public static void printElementDownbound(List<? super Integer> data) {for(int i=0;i<data.size();i++) {System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));}}
}

在这个例子中，printElementDownbound方法中的集合泛型，可以是Integer或其父类型，即类型下限是Integer，除此之外的其他类型都不行。也就是说，我们只能使用Integer或其父类作为类型参数，泛型类型的下限是Integer，这就是下限通配符的含义。

7. <? extends T>和<? super T>的区别

在这里，要给大家再总结一下<? extends T>和<? super T>的区别：

• <? extends T> 允许调用 T get()这样的 读方法来获取 T对象 的引用，但不允许调用 set(T)这样的 写方法来传入 T 的引用(传入 null 除外)；
• <? super T> 允许调用 set(T)这样的 写方法传入 T对象 的引用，但不允许调用 T get()这样的 读方法来获取 T对象 的引用(获取 Object 除外)。
• 即 <? extends T> 允许读不允许写， <? super T> 允许写不允许读。

大家注意，无论是未限定通配符、上限通配符还是下限通配符，我们既可以在方法中使用，也可以在类或接口中使用。

三. 泛型擦除

我们在学习泛型时，除了要掌握上面这些泛型类、泛型接口、泛型方法以及通配符等内容之外，还要学习泛型擦除的相关内容。那么什么是泛型擦除呢？我们继续往下学习吧。

1. 简介

所谓的泛型擦除(Type Erasure)，就是指在编译时，JVM编译器会将所有的泛型信息都擦除掉，变成原始类型，一般是将泛型的类型参数替换成具体类型的上限或下限(如果没有指定上界，则默认为Object)。

换句话说，虽然我们在代码中使用了泛型，但在编译后，所有的泛型类型都会被擦除掉，转而使用其对应的原始类型。这就是Java泛型的底层实现原理。这样设计的目的是为了兼容旧的JDK版本，使得Java具有了较好的向后兼容性，旧的非泛型代码可以直接使用泛型类库，而不需要进行任何修改。同时，Java也提供了反射机制来操作泛型类型，使得泛型类型在某些情况下还是可以被获取到的，所以即使有泛型擦除，仍然也不会太影响Java虚拟机的运行时效率。

比如，在我们定义一个泛型类时，我们会使用泛型类型参数来代替具体的类型，好比下面这个例子：

2. 泛型擦除带来的限制

在编译之后，这个泛型类的类型参数T就会被擦除，成为其对应的原始类型Object。

这也意味着，我们无法在运行时获取到泛型的实际类型参数，所以泛型擦除的使用会有一些限制。首先由于泛型类型参数被擦除了，因此我们在运行时就无法获得泛型类型参数的信息。例如，如果我们有一个List类型的变量，在运行时我们就无法获得这个List集合中的元素类型是Integer。另一个限制是在使用泛型类型时，还需要注意类型安全性。在编译阶段，编译器会检查泛型类型的类型安全性；但在运行阶段，由于泛型类型参数被擦除了，因此就无法保证类型安全性了。泛型擦除的限制，主要表现在以下几个方面：

无法使用基本类型实例化类型参数；

无法在运行时获取泛型类型信息；

泛型类型参数不能用于静态变量或静态方法；

不能实例化T类型。

接下来再给大家具体分析一下这些限制

2.1 无法使用基本类型实例化类型参数

Java泛型中的类型参数不能是基本类型，只能是类或接口类型。例如，以下代码在编译阶段会出错，无法通过编译：

List<int> list = new ArrayList<int>();

正确的写法是使用基本类型对应的包装类型，如下所示：

List<Integer> list = new ArrayList<Integer>();

2.2 无法在运行时获取泛型类型信息

由于泛型擦除的存在，导致我们在程序运行时无法获取泛型类型的信息。例如，以下代码在运行时就无法获取List的元素类型：

List<String> list = new ArrayList<String>(); 
Class<?> clazz = list.getClass(); 
Type type = clazz.getGenericSuperclass(); 
// 输出：class java.util.ArrayList<E>
System.out.println(type); 

在输出的结果中，我们只能得到ArrayList的类型信息，而无法获取到集合中具体的泛型类型信息，也就是获取不到String的信息。但如果我们就是想在运行时获取到泛型的实际类型参数，其实可以参考以下方式进行实现：

public class Box<T> {private T content;public Box(T content) {this.content = content;}public T getContent() {return content;}public void setContent(T content) {this.content = content;}public Class<?> getContentType() {return content.getClass();}
}

在上面的代码中，我们新增了一个方法 getContentType()，该方法用于返回泛型类型参数的实际字节码类型，以后我们通过调用这个方法，就可以间接地获取到泛型类型的信息了。

2.3 泛型类型参数不能用于静态变量或静态方法

由于泛型类型参数是在实例化对象时才被确定的，因此不能在静态变量或静态方法中使用泛型类型参数。例如，以下代码是无法编译通过的：

public class MyClass<T> {   //这样的代码编译不通过private static T value;   public static void setValue(T value) {        MyClass.value = value;     } 
}

正确的写法是使用一个实际类型来代替泛型类型参数：

public class MyClass {     private static String value;          public static void setValue(String value) {         MyClass.value = value;     } 
}

2.4 不能实例化T类型

比如在下面的案例中：

public class MyClass<T> {private T first;private T last;public MyClass() {first = new T();last = new T();}
}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T(); 
last = new T(); 

擦拭后实际上变成了：

first = new Object(); 
last = new Object(); 

这样一来，创建new MyClass<String>()和创建new MyClass<Integer>()就变成了Object，编译器会阻止这种类型不对的代码。如果我们想对泛型T进行实例化，需要借助Class< T >参数并集合反射技术来实现，且在使用时也必须传入Class< T >。

---

四. 结语

不过，尽管泛型擦除有一些限制，但泛型仍然不失为一种强大的编程工具，它可以提高代码的可读性和可维护性。通过合理地使用泛型，我们可以在编译时进行类型检查，避免类型转换的错误和运行时异常，从而提高了代码的安全性和可靠性。同时，我们也需要了解Java泛型擦除的限制，以便在实际应用中做出正确的决策。

视频教程：视频教程，戳我直达