一、概述
Java语言作为一种静态强类型语言，在设计过程中必须平衡类型安全、灵活性以及代码的可复用性。泛型机制便是Java在1.5版本中引入的强大工具，旨在实现类型安全的集合操作及代码的通用化。
什么是泛型？为什么要使用泛型？
泛型即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的基本设计目标，即增强类型检查和减少强制类型转换。这一设计极大地提升了代码的类型安全性，但也带来了一个重要的问题：泛型的类型参数化一旦定义，就变得非常严格，从而限制了一些灵活性。在实际项目中，往往需要解决更具通用性的问题，这时就需要Java泛型的通配符来帮助处理这些类型的不确定性。
二、泛型使用
泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。
2.1 泛型类
2.1.1 泛型类的定义
（1）泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。
泛型类的最基本写法：
class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型> {
private 泛型标识 /*（成员变量类型）*/ 变量名;
//...
}
泛型标识是任意设置的（A-Z都行），Java常见的泛型标识以及其代表含义如下：
- T：代表一般的任何类。
- E：代表Element元素的意思，或者Exception异常的意思。
- K：代表Key的意思。
- V：代表Value的意思，通常与K一起配合使用。
- S：代表Subtype的意思，文章后面部分会讲解示意。
一个最普通的泛型类：
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T> {
//key这个成员变量的类型为T，T的类型由外部指定
private T key;
//泛型构造方法形参key的类型也为T，T的类型由外部指定
public Generic(T key) {
this.key = key;
}
//泛型方法getKey的返回值类型为T，T的类型由外部指定
public T getKey() {
return key;
}
}
（2）泛型类中的静态方法和静态变量不可以使用泛型类所声明的类型参数
代码如下：
public class Test<T> {
public static T one; // 编译错误
public static T show(T one){ // 编译错误
return null;
}
}
泛型类中的类型参数的确定是在创建泛型类对象的时候（例如ArrayList ）。
而静态变量和静态方法在类加载时已经初始化，直接使用类名调用；在泛型类的类型参数未确定时，静态成员有可能被调用，因此泛型类的类型参数是不能在静态成员中使用的。
（3）静态泛型方法中可以使用自身的方法签名中新定义的类型参数（即泛型方法，后面会说到），而不能使用泛型类中定义的类型参数。
代码如下：
public class Test2<T> {
// 泛型类定义的类型参数 T 不能在静态方法中使用
public static <E> E show(E one){ // 这是正确的，因为 E 是在静态方法签名中新定义的类型参数
return null;
}
}
（4）泛型类不只接受一个类型参数，它还可以接受多个类型参数。
代码如下：
public class MultiType<E, T> {
E value1;
T value2;
public E getValue1() {
return value1;
}
public T getValue2() {
return value2;
}
}
2.1.2 泛型类的使用
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
看一个例子：
Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);
注意：
泛型的类型参数只能是类类型，不能是简单类型。
不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
if(ex_num instanceof Generic<Number>) {
}
2.2 泛型接口
泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
当实现泛型接口的类，未传入泛型实参时：
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T> {
@Override
public T next() {
return null;
}
}
当实现泛型接口的类，传入泛型实参时：
/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
2.3 泛型方法
在java中，泛型类的定义非常简单，但是泛型方法就比较复杂了。
尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。
/**
* 泛型方法的基本介绍
* @param tClass 传入的泛型实参
* @return T 返回值为T类型
* 说明：
* 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
* 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
* 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T genericMethod(Class<T> tClass) throws InstantiationException, IllegalAccessException {
T instance = tClass.newInstance();
return instance;
}
Object obj = genericMethod(Class.forName("com.test.test"));
2.3.1 泛型方法的基本用法
光看上面的例子有的同学可能依然会非常迷糊，我们再通过一个例子，把我泛型方法再总结一下。
public class GenericTest {
//这个类是个泛型类，在上面已经介绍过
public class Generic<T> {
private T key;
public Generic(T key) {
this.key = key;
}
//我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
//所以在这个方法中才可以继续使用 T 这个泛型。
public T getKey() {
return key;
}
/**
* 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
* 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
public E setKey(E key) {
this.key = keu
}
*/
}
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public <T, K> K showKeyName(Generic<T> container) {
* ...
* }
*/
public <T> T showKeyName(Generic<T> container) {
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
//这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
public void showKeyValue1(Generic<Number> obj) {
System.out.println("key value is " + obj.getKey());
}
//这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj) {
System.out.println("key value is " + obj.getKey());
}
/**
* 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public <T> T showKeyName(Generic<E> container) {
...
}
*/
/**
* 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showkey(T genericObj) {
}
*/
public static void main(String[] args) {
}
}
2.3.2 类中的泛型方法
当然这并不是泛型方法的全部，泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下
public class GenericFruit {
class Fruit {
@Override
public String toString() {
return "fruit";
}
}
class Apple extends Fruit {
@Override
public String toString() {
return "apple";
}
}
class Person {
@Override
public String toString() {
return "Person";
}
}
class GenerateTest<T> {
public void show_1(T t) {
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t) {
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t) {
System.out.println(t.toString());
}
}
public static void main(String[] args) {
Apple apple = new Apple();
Person person = new Person();
GenerateTest<Fruit> generateTest = new GenerateTest<>();
//apple是Fruit的子类，所以这里可以
generateTest.show_1(apple);
//编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
//generateTest.show_1(person);
//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}
2.3.3 泛型方法与可变参数
再看一个泛型方法和可变参数的例子：
public <T> void printMsg(T... args) {
for (T t : args) {
System.out.println("t is " + t);
}
}
printMsg("111", 222, "aaaa", "2323.4", 55.55);
2.3.4 静态方法与泛型
静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。
public class StaticGenerator<T> {
//...
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t) {
}
}
2.3.5 泛型方法总结
泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：
无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。
三、类型擦除
3.1 什么是类型擦除
泛型的本质是将数据类型参数化，它通过擦除的方式来实现，即编译器会在编译期间擦除代码中的所有泛型语法并相应的做出一些类型转换动作。
换而言之，泛型信息只存在于代码编译阶段，在代码编译结束后，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。也就是说，成功编译过后的class文件中不包含任何泛型信息，泛型信息不会进入到运行时阶段。
其实Java中的泛型本质是伪泛型
当把集合定义为string类型的时候，当数据添加在集合当中的时候，仅仅在门口检查了一下数据是否符合String类型，如果是String类型，就添加成功，当添加成功以后，集合还是会把这些数据当做Object类型处理，当往外获取的时候，集合在把他强转String类型
当代码编译到class文件的时候，泛型就消失，叫泛型的擦除
看一个例子，假如我们给ArrayList集合传入两种不同的数据类型，并比较它们的类信息。
public class GenericType {
public static void main(String[] args) {
ArrayList<String> arrayString = new ArrayList<String>();
ArrayList<Integer> arrayInteger = new ArrayList<Integer>();
System.out.println(arrayString.getClass() == arrayInteger.getClass());// true
}
}
在这个例子中，我们定义了两个ArrayList集合，不过一个是ArrayList<String>，只能存储字符串。一个是ArrayList<Integer>，只能存储整型对象。我们通过arrayString对象和arrayInteger对象的getClass()方法获取它们的类信息并比较，发现结果为true。
明明我们在<>中传入了两种不同的数据类型，那为什么它们的类信息还是相同呢？这是因为，在编译期间，所有的泛型信息都会被擦除，ArrayList<Integer>和ArrayList<String>类型，在编译后都会变成ArrayList<Object>类型。
那么是不是所有的类型参数被擦除后都以Object类进行替换呢？
答案是否定的，大部分情况下，类型参数T被擦除后都会以Object类进行替换；而有一种情况则不是，那就是使用到了extends和super语法的有界类型参数(即泛型通配符)
3.2 类型擦除的原理
假如我们定义了一个ArrayList<Integer>泛型集合，若向该集合中插入String类型的对象，不需要运行程序，编译器就会直接报错。这里可能有小伙伴就产生了疑问：
- 不是说泛型信息在编译的时候就会被擦除掉吗？那既然泛型信息被擦除了，如何保证我们在集合中只添加指定的数据类型的对象呢？
- 换而言之，我们虽然定义了
ArrayList<Integer>泛型集合，但其泛型信息最终被擦除后就变成了ArrayList<Object>集合，那为什么不允许向其中插入String对象呢？
Java是如何解决这个问题的？
其实在创建一个泛型类的对象时，Java编译器是先检查代码中传入<T>的数据类型，并记录下来，然后再对代码进行编译，编译的同时进行类型擦除；如果需要对被擦除了泛型信息的对象进行操作，编译器会自动将对象进行类型转换。
可以把泛型的类型安全检查机制和类型擦除想象成演唱会的验票机制：以
ArrayList<Integer>泛型集合为例。
- 当我们在创建一个
ArrayList<Integer>泛型集合的时候，ArrayList可以看作是演唱会场馆，而<T>就是场馆的验票系统，Integer是验票系统设置的门票类型；- 当验票系统设置好为
<Integer>后，只有持有Integer门票的人才可以通过验票系统，进入演唱会场馆（集合）中；若是未持有Integer门票的人想进场，则验票系统会发出警告（编译器报错）。- 在通过验票系统时，门票会被收掉（类型擦除），但场馆后台（JVM）会记录下观众信息（泛型信息）。
- 进场后的观众变成了没有门票的普通人（原始数据类型）。但是，在需要查看观众的信息时（操作对象），场馆后台可以找到记录的观众信息（编译器会自动将对象进行类型转换）。
举例如下：
public class GenericType {
public static void main(String[] args) {
ArrayList<Integer> arrayInteger = new ArrayList<Integer>();// 设置验票系统
arrayInteger.add(111);// 观众进场，验票系统验票，门票会被收走（类型擦除）
Integer n = arrayInteger.get(0);// 获取观众信息，编译器会进行强制类型转换
System.out.println(n);
}
}
擦除ArrayList<Integer>的泛型信息后，get()方法的返回值将返回Object类型，但编译器会自动插入Integer的强制类型转换。也就是说，编译器把get()方法调用翻译为两条字节码指令：
- 对原始方法get()的调用，返回的是Object类型；
- 将返回的Object类型强制转换为Integer类型；
代码如下：
Integer n = arrayInteger.get(0);// 这条代码底层如下：
//（1）get()方法的返回值返回的是Object类型
Object object = arrayInteger.get(0);
//（2）编译器自动插入Integer的强制类型转换
Integer n = (Integer) object;
3.3 类型擦除小结
1.泛型信息（包括泛型类、接口、方法）只在代码编译阶段存在，在代码成功编译后，其内的所有泛型信息都会被擦除，并且类型参数T会被统一替换为其原始类型（默认是Object类，若有extends或者super则另外分析）；
2.在泛型信息被擦除后，若还需要使用到对象相关的泛型信息，编译器底层会自动进行类型转换（从原始类型转换为未擦除前的数据类型）。
四、泛型通配符
4.1 泛型的继承
在介绍泛型通配符之前，先提出一个问题，在Java的多态中，我们知道可以将一个子类对象赋值给其父类的引用，这也叫向上转型。
举例如下：
public class GenericType {
public static void main(String[] args) {
List list = new ArrayList();
}
}
上面的代码很好得体现了Java的多态特性。
在Java标准库中的集合ArrayList<T>类实现了List<T>接口，其源码大致如下：
public class ArrayList<T> implements List<T> {
//...
}
那现在我们思考一个问题，在ArrayList<T>泛型集合中，当传入<T>中的数据类型相同时，是否还能将一个ArrayList<T>对象赋值给其父类的引用List<T>。
代码如下：
public class GenericType {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
}
}
上面的代码没有问题，即ArrayList<T>对象可以向上转型为List<T>，但两者传入<T>中的数据类型必须相同。
继续思考一个问题，已知Integer类是Number类的子类，那如果ArrayList<>泛型集合中，在<>之间使用向上转型，也就是将ArrayList<Integer>对象赋值给List<Number>的引用，是否被允许呢？
举例如下：
public class GenericType {
public static void main(String[] args) {
List<Number> list01 = new ArrayList<Integer>();// 编译错误
ArrayList<Number> list02 = new ArrayList<Integer>();// 编译错误
}
}
上面代码会报错，我们发现并不能把ArrayList<Integer>对象赋值给List<Number>的引用，甚至不能把ArrayList<Integer>对象赋值给ArrayList<Number>的引用。这也说明了在一般泛型中，不能向上转型。
这是为什么？如果我们假设ArrayList<Integer>可以向上转型为ArrayList<Number>。
观察下面代码：
public class GenericType {
public static void main(String[] args) {
// 创建一个 ArrayList<Integer> 集合
ArrayList<Integer> integerList = new ArrayList<>();
// 添加一个 Integer 对象
integerList.add(new Integer(123));
// “向上转型”为 ArrayList<Number>
ArrayList<Number> numberList = integerList;
// 添加一个 Float 对象，Float 也是 Number 的子类，编译器不报错
numberList.add(new Float(12.34));
// 从 ArrayList<Integer> 集合中获取索引为 1 的元素（即添加的 Float 对象）：
Integer n = integerList.get(1); // ClassCastException，运行出错
}
}
当我们把一个ArrayList<Integer>向上转型为ArrayList<Number>类型后，这个ArrayList<Number>集合就可以接收Float对象了，因为Float类是Number类的子类。
但是，ArrayList<Number>实际上和ArrayList<Integer>是同一个集合，而在泛型的定义中，ArrayList<Integer>集合是不可以接收Float对象的。这是因为，在使用get()方法获取集合元素的时候，编译器会自动将Float对象强转成Integer对象，而这会产生ClassCastException异常。
正因如此，编译器为了避免发生这种错误，根本就不允许把ArrayList<Integer>对象向上转型为ArrayList<Number>；换而言之，ArrayList<Integer>和ArrayList<Number>两者之间没有继承关系。
4.2 泛型通配符的引入
我们上面讲到了泛型的继承关系，ArrayList<Integer>不是ArrayList<Number>的子类。
（1）先看一个问题：假设我们定义了一个Pair<T>类，如下：
public class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
public void setFirst(T first) {
this.first = first;
}
public void setLast(T last) {
this.last = last;
}
}
（2）然后，我们针对Pair<Number>类型写了一个静态方法，它接收的参数类型是Pair<Number>。
代码如下：
public class PairHelper {
static int addPair(Pair<Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}
（3）在测试类中创建一个Pair<Number>对象，并调用addPair()方法。
代码如下：
public class Main {
public static void main(String[] args) {
Pair<Number> pair = new Pair<>(1, 2);
int sum = PairHelper.addPair(pair);
}
}
（4）上面的代码正常编译运行。但我们发现，在实际创建Pair<Number>对象的时候，我们传入的实参(1,2)实际上是Integer类型；那我们是否可以直接创建一个Pair<Integer>对象，并将其传给add()方法呢？
代码如下：
public class Main {
public static void main(String[] args) {
Pair<Integer> pairInteger = new Pair<>(123, 456);
int sum = PairHelper.addPair(pairInteger);
}
}
编译器会直接报错，原因是Pair<Integer>并不是Pair<Number>的子类，而addPair()方法的形参数据类型为Pair<Number>。因此，Pair<Integer>对象不能传给addPair()方法。
那有没有办法使得addPair()方法可以接收Pair<Integer>对象？总不能重新定义一个新的addPair()方法来处理Pair<Integer>对象吧，这显然与Java中的多态理念相违背。
因此我们需要一个在逻辑上可以表示为Pair<Integer>和Pair<Number>这两者的父类引用类型，由此，泛型通配符便应运而生。
4.3 什么是泛型通配符
在现实编码中，确实有这样的需求，希望泛型能够处理某一类型范围内的类型参数，比如某个泛型类和它的子类，为此Java引入了泛型通配符这个概念。
泛型通配符有3种形式：
- ：被称作无限定的通配符。
- ：被称作有上界的通配符。表示某个类是T或T的子类，称为协变。协变的目的是允许我们读取该集合内的对象，但不能安全地往集合中添加新对象。
- ：被称作有下界的通配符。表示某个类是T或T的父类，称为逆变。逆变的目的是允许我们往集合中添加对象，但读取对象时只能读取为Object类型，因为集合中的类型上界无法确定。
在引入泛型通配符之后，我们便得到了一个在逻辑上可以表示为某一类型参数范围的父类引用类型。举例来说，泛型通配符可以表示Pair<Integer>和Pair<Number>两者的父类引用类型。
<? extends T>和<? super T>的主要动机是为了应对协变与逆变的问题。
接下来将分别介绍3种形式的泛型通配符。
4.4 上界通配符(协变)
4.4.1 协变的定义
上界通配符<? extends T>：T代表了类型参数的上界，<? extends T>表示类型参数的范围是T和T的子类。需要注意的是：<? extends T>也是一个数据类型实参，它和Number、String、Integer一样都是一种实际的数据类型。
（1）在泛型的继承中我们说到，ArrayList<Integer>和ArrayList<Number>之间不存在继承关系。而引入上界通配符的概念后，我们便可以在逻辑上将ArrayList<? extends Number>看做是ArrayList<Integer>的父类，但实质上它们之间没有继承关系。
举例如下：
public class GenericType {
public static void main(String[] args) {
ArrayList<Number> list01 = new ArrayList<Integer>();// 编译错误
ArrayList<? extends Number> list02 = new ArrayList<Integer>();// 编译正确
}
}
逻辑上可以将ArrayList<? extends Number>看做是ArrayList<Integer>的父类，因此，在使用了上界通配符<? extends Number>后，便可以将ArrayList<Integer>对象向上转型了。
（2）ArrayList<? extends Number>可以代表ArrayList<Integer>、ArrayList<Float>、…、ArrayList<Number>中的某一个集合，但我们不能指定ArrayList<? extends Number>的数据类型。（这里有点难理解）
举个例子：
public class GenericType {
public static void main(String[] args) {
ArrayList<? extends Number> list = new ArrayList<>();
list.add(new Integer(1));// 编译错误
list.add(new Float(1.0));// 编译错误
}
}
可以这样理解，ArrayList<? extends Number>集合表示了：我这个集合可能是ArrayList<Integer>集合，也可能是ArrayList<Float>集合，…，还可能是ArrayList<Number>集合；但到底是哪一个集合，不能确定；程序员也不能指定。
所以，在上面代码中，创建了一个ArrayList<? extends Number>集合list，但我们并不能往list中添加Integer、Float等对象，这也说明了list集合并不是某个确定了数据类型的集合。
思考：那既然
ArrayList<? extends Number>可以代表ArrayList<Integer>或ArrayList<Float>，为什么不能向其中加入Integer、Float等对象呢？
其原因是ArrayList<? extends Number>表示的是一个未知类型的ArrayList集合，它可以代表ArrayList<Integer>或ArrayList<Float>…等集合，但却不能确定它到底是ArrayList<Integer>还是ArrayList<Float>集合。
因此，泛型的特性决定了不能往ArrayList<? extends Number>集合中加入Integer、Float等对象，以防止在获取ArrayList<? extends Number>集合中元素的时候，产生ClassCastException异常。
那为什么还需要引入上界统配符的概念？—-答：是为了拓展方法形参中类型参数的范围。
（1）在泛型通配符的引入部分，我们提出了一个问题，有没有办法使得addPair(Pair<Number> p)方法接收Pair<Integer>对象?而在有了上界通配符的概念后，这个问题便有了解决办法，就是将addPair()方法改写。
代码如下：
// 改写前
public class PairHelper {
static int addPair(Pair<Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}
// 改写后
public class PairHelper {
static int addPair(Pair<? extends Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}
改写addPair()方法，用<? extends Number>替换了<Number>，由于Pair<Integer>可以向上转型为Pair<? extends Number>，所以调用addPair()方法时，我们便可以传入Pair<Integer>对象了。
除了可以传入Pair<Integer>对象，我们还可以传入Pair<Double>对象，Pair<BigDecimal>对象等等，因为Double类和BigDecimal类也都是Number的子类。
4.4.2 协变的用法
上面说到，我们无法确定ArrayList<? extends Number>具体是什么数据类型的集合，因此其add()方法会受限（即不能往集合中添加任何数据类型的对象）；但是可以往集合中添加null，因为null表示任何类型。
我们可以调用get()方法从集合中获取元素，并赋值给集合中的最高父类Number(即<? extends T>的上界)。
（1）上界通配符<? extends T>的正确用法：
public class Test {
public static void main(String[] args) {
// 创建一个 ArrayList<Integer> 集合
ArrayList<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
// 将 ArrayList<Integer> 传入 printIntVal() 方法
printIntVal(integerList);
// 创建一个 ArrayList<Float> 集合
ArrayList<Float> floatList = new ArrayList<>();
floatList.add((float) 1.0);
floatList.add((float) 2.0);
// 将 ArrayList<Float> 传入 printIntVal() 方法
printIntVal(floatList);
}
public static void printIntVal(ArrayList<? extends Number> list) {
// 遍历传入的集合，并输出集合中的元素
for (Number number : list) {
System.out.print(number.intValue() + " ");
}
System.out.println();
}
}
输出如下：
1 2
1 2
在printIntVal()方法中，其形参为ArrayList<? extends Number>，因此，可以给该方法传入ArrayList<Integer>、ArrayList<Float>等集合。
需要注意的是：在printIntVal()方法内部，必须要将传入集合中的元素赋值给Number对象，而不能赋值给某个子类对象；是因为根据ArrayList<? extends Number>的特性，并不能确定传入集合的数据类型（即不能确定传入的是ArrayList<Integer>还是ArrayList<Float>）。
假设在printIntVal()方法中存在下面代码：
Integer intNum = (Integer) number;
若是传入集合为ArrayList<Float>，则必然会产生ClassCastException异常。
（2）上界通配符<? extends T>的错误用法：
public class Test {
public static void main(String[] args) {
ArrayList<? extends Number> list = new ArrayList();
list.add(null);// 编译正确
list.add(new Integer(1));// 编译错误
list.add(new Float(1.0));// 编译错误
}
public static void fillNumList(ArrayList<? extends Number> list) {
list.add(new Integer(0));//编译错误
list.add(new Float(1.0));//编译错误
list.set(0, new Integer(2));// 编译错误
list.set(0, null);// 编译成功，但不建议这样使用
}
}
在ArrayList<? extends Number>集合中，不能添加任何数据类型的对象，只能添加空值null，因为null可以表示任何数据类型。
4.4.3 协变小结
一句话总结：使用extends通配符表示可以读，不能写。
4.5 下界通配符(逆变)
4.5.1 逆变的定义
下界通配符<? super T>：T代表了类型参数的下界，<? super T>表示类型参数的范围是T和T的超类，直至Object。需要注意的是：<? super T>也是一个数据类型实参，它和Number、String、Integer一样都是一种实际的数据类型。
（1）ArrayList<? super Integer>在逻辑上表示为Integer类以及Integer类的所有父类，它可以代表ArrayList<Integer>、ArrayList<Number>、ArrayList<Object>中的某一个集合，但实质上它们之间没有继承关系。
举个例子：
public class GenericType {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<Number>();// 编译错误
ArrayList<? super Integer> list02 = new ArrayList<Number>();// 编译正确
}
}
逻辑上可以将ArrayList<? super Integer>看做是ArrayList<Number>的父类，因此，在使用了下界通配符<? super Integer>后，便可以将ArrayList<Number>对象向上转型了。
（2）ArrayList<? super Integer>只能表示指定类型参数范围中的某一个集合，但我们不能指定ArrayList<? super Integer>的数据类型。（这里有点难理解）
看一个例子：
public class GenericType {
public static void main(String[] args) {
ArrayList<? super Number> list = new ArrayList<>();
list.add(new Integer(1));// 编译正确
list.add(new Float(1.0));// 编译正确
// Object 是 Number 的父类
list.add(new Object());// 编译错误
}
}
这里奇怪的地方出现了，为什么和ArrayList<? extends Number>集合不同，ArrayList<? super Number>集合中可以添加Number类及其子类的对象呢？
其原因是，ArrayList<? super Number>的下界是ArrayList<Number>。因此，我们可以确定Number类及其子类的对象自然可以加入ArrayList<? super Number>集合中；而Number类的父类对象就不能加入ArrayList<? super Number>集合中了，因为不能确定ArrayList<? super Number>集合的数据类型。
4.5.2 逆变的用法
（1）下界通配符<? super T>的正确用法：
public class Test {
public static void main(String[] args) {
// 创建一个 ArrayList<? super Number> 集合
ArrayList<Number> list = new ArrayList();
// 往集合中添加 Number 类及其子类对象
list.add(new Integer(1));
list.add(new Float(1.1));
// 调用 fillNumList() 方法，传入 ArrayList<Number> 集合
fillNumList(list);
System.out.println(list);
}
public static void fillNumList(ArrayList<? super Number> list) {
list.add(new Integer(0));
list.add(new Float(1.0));
}
}
输出如下：
[1, 1.1, 0, 1.0]
与带有上界通配符的集合ArrayList<? extends T>的用法不同，带有下界通配符的集合ArrayList<? super Number>中可以添加Number类及其子类的对象；ArrayList<? super Number>的下界就是ArrayList集合，因此，其中必然可以添加Number类及其子类的对象；但不能添加Number类的父类对象（不包括Number类）。
（2）下界通配符<? super T>的错误用法：
public class Test {
public static void main(String[] args) {
// 创建一个 ArrayList<Integer> 集合
ArrayList<Integer> list = new ArrayList<>();
list.add(new Integer(1));
// 调用 fillNumList() 方法，传入 ArrayList<Integer> 集合
fillNumList(list);// 编译错误
}
public static void fillNumList(ArrayList<? super Number> list) {
list.add(new Integer(0));// 编译正确
list.add(new Float(1.0));// 编译正确
// 遍历传入集合中的元素，并赋值给 Number 对象；会编译错误
for (Number number : list) {
System.out.print(number.intValue() + " ");
System.out.println();
}
// 遍历传入集合中的元素，并赋值给 Object 对象；可以正确编译
// 但只能调用 Object 类的方法，不建议这样使用
for (Object obj : list) {
System.out.println(obj);使用
}
}
}
注意，ArrayList<? super Number>代表了ArrayList<Number>、ArrayList<Object>中的某一个集合，而ArrayList<Integer>并不属于ArrayList<? super Number>限定的范围，因此，不能往fillNumList()方法中传入ArrayList<Integer>集合。
并且，不能将传入集合的元素赋值给Number对象，因为传入的可能是ArrayList<Object>集合，向下转型可能会产生ClassCastException异常。
不过，可以将传入集合的元素赋值给Object对象，因为Object是所有类的父类，不会产生ClassCastException异常，但这样的话便只能调用Object类的方法了，不建议这样使用。
4.5.3 逆变小结
一句话总结：使用super通配符表示可以写，不能读。
4.6 无限定通配符
我们已经讨论了和作为方法参数的作用。实际上，Java的泛型还允许使用无限定通配符，即只定义一个?符号。
无界通配符：?代表了任何一种数据类型，能代表任何一种数据类型的只有null。需要注意的是：也是一个数据类型实参，它和Number、String、Integer一样都是一种实际的数据类型。
注意：
Object本身也算是一种数据类型，但却不能代表任何一种数据类型，所以ArrayList<Object>和ArrayList的含义是不同的，前者类型是Object，也就是继承树的最高父类，而后者的类型完全是未知的；ArrayList是ArrayList<Object>逻辑上的父类。
（1）ArrayList<?>在逻辑上表示为所有数据类型的父类，它可以代表ArrayList<Integer>、ArrayList<Number>、ArrayList<Object>中的某一个集合，但实质上它们之间没有继承关系。
举例如下：
public class GenericType {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>(123, 456);
ArrayList<?> list02 = list01; // 安全地向上转型
}
}
上述代码是可以正常编译运行的，因为ArrayList<?>在逻辑上是ArrayList<Integer>的父类，可以安全地向上转型。
（2）ArrayList既没有上界也没有下界，因此，它可以代表所有数据类型的某一个集合，但我们不能指定ArrayList的数据类型。
举例如下：
public class GenericType {
public static void main(String[] args) {
ArrayList<?> list = new ArrayList<>();
list.add(null);// 编译正确
Object obj = list.get(0);// 编译正确
list.add(new Integer(1));// 编译错误
Integer num = list.get(0);// 编译错误
}
}
ArrayList集合的数据类型是不确定的，因此我们只能往集合中添加null；而我们从ArrayList集合中取出的元素，也只能赋值给Object对象，不然会产生ClassCastException异常（原因可以结合上界和下界通配符理解）。
（3）大多数情况下，可以用类型参数<T>代替<?>通配符。
举例如下：
static <?> void isNull(ArrayList<?> list) {
//...
}
// 替换如下：
static <T> void isNull(ArrayList<T> list) {
//...
}
4.7 协变与逆变对比
（1）对于<? extends 类型>，编译器将只允许读操作，不允许写操作。即只可以取值，不可以设值。
（2）对于<? super 类型>，编译器将只允许写操作，不允许读操作。即只可以设值（比如set操作），不可以取值（比如get操作）。
以上两点都是针对于源码里涉及到了类型参数的方法而言的。比如对于List而言，不允许的写操作有add方法，因为它的方法签名是boolean add(E e);，此时这个形参E就变成了一个涉及了通配符的类型参数；而不允许的读操作有get方法，因为它的方法签名是E get(int index);，此时这个返回值E就变成了一个涉及了通配符的类型参数。
作为方法形参，<? extends T>类型和<? super T>类型的区别在于：
- 允许调用读方法
T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）。 - 允许调用写方法
set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。
先记住上面的结论，我们来看Java标准库的Collections类定义的copy()方法。
（1）copy()方法的作用是把一个List中的每个元素依次添加到另一个List中。它的第一个形参是List<? super T>，表示目标List，第二个形参是List<? extends T>，表示源List。
代码如下：
public class Collections {
// 把 src 的每个元素复制到 dest 中:
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
// 获取 src 集合中的元素，并赋值给变量 t，其数据类型为 T
T t = src.get(i);
// 将变量 t 添加进 dest 集合中
dest.add(t);// 添加元素进入 dest 集合中
}
}
}
我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于<? extends T>集合src，我们可以安全地获取类型参数T的引用（即变量t），而对于<? super T>的集合dest，我们可以安全地传入类型参数T的引用。
（2）copy()方法的定义完美地展示了通配符extends和super的意图：
- copy()方法内部不会读取dest，因为不能调用dest.get()方法来获取T的引用（如果调用则编译器会直接报错）。
- copy()方法内部也不会修改src，因为不能调用src.add(T)方法（如果调用则编译器会直接报错）。这是由编译器检查来实现的。如果在方法代码中意外修改了src集合，或者意外读取了dest，就会导致一个编译错误。
代码如下：
public class Collections {
// 把 src 的每个元素复制到 dest 中:
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
// ...
// 获取 <? super T> 集合的元素只能赋值给 Object 对象
T t = dest.get(0); // 编译错误
// 不能向 <? extends T> 集合中添加任何类型的对象，除了 null
src.add(t); // 编译错误
}
}
根据上面介绍的，获取<? super T>集合dest的元素后只能赋值给Object对象，而不能赋值给其下界类型T；我们不能向<? extends T>集合src中添加任何类型的对象，除了null。
（3）copy()方法的另一个好处是可以安全地把一个List 添加到List ，但是无法反过来添加。
代码如下：
// 将List<Integer>复制到List<Number>
List<Number> numList = ...;
List<Integer> intList = ...;
Collections.copy(numList, intList);// 编译正确
// 不能将 List<Number> 复制到 List<Integer>
Collections.copy(intList, numList);// 编译错误
这个很好理解，List<Number>集合中可能有Integer、Float等对象，所以肯定不能复制到List<Integer>集合中；而List<Integer>集合中只有Integer对象，因此肯定可以复制到List<Number>集合中。
4.8 PECS原则
我们何时使用extends，何时使用super通配符呢？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。
即：如果需要返回T，则它是生产者（Producer），要使用extends通配符；如果需要写入T，则它是消费者（Consumer），要使用super通配符。
还是以`Collections的copy()方法为例：
public class Collections {
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
T t = src.get(i); // src 是 producer
dest.add(t); // dest 是 consumer
}
}
}
需要返回T的src是生产者，因此声明为List<? extends T>，需要写入T的dest是消费者，因此声明为List<? super T>。
4.9 关于泛型数组要提一下
看到了很多文章中都会提起泛型数组，经过查看sun的说明文档，在java中是”不能创建一个确切的泛型类型的数组”的。
也就是说下面的这个例子是不可以的：
List<String>[] ls = new ArrayList<String>[10];
而使用通配符创建泛型数组是可以的，如下面这个例子：
List<?>[] ls = new ArrayList<?>[10];
这样也是可以的：
List<String>[] ls = new ArrayList[10];
下面使用Sun的一篇文档的一个例子来说明这个问题：
List<String>[] lsa = new List<String>[10]; // Not really allowed.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // Unsound, but passes run time store check
String s = lsa[1].get(0); // Run-time error: ClassCastException.
这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。
而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。
下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。
List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // Correct.
Integer i = (Integer) lsa[1].get(0); // OK
五、总结
本文中的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。
参考
来源链接：https://www.cnblogs.com/ciel717/p/18829678
如有侵犯您的版权，请及时联系3500663466#qq.com(#换@)，我们将第一时间删除本站数据。
暂无评论内容