前言

对于泛型，我们的学习目的：看得懂就可以了。因为泛型是 java 当中比较难的一块语法了。

什么是泛型？

一般的类和方法，只能使用具体的类型；基本类型，或者是自定义的类。如果要编写可以用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。 ------- 来自《Java编程思想》
泛型是在JDK1.5引入的新语法，通俗讲：泛型 ->就是适用于很多类型。从代码上讲，就死对类型实现了参数化（将类作为参数进行传递）。

引出泛型

实现一个类似顺序表的类，使得底层的数组可以存放任何类型的数据，也可以根据成员方法来返回数组中某个下标的值
思路：
1.我们以前学过的数组，只能存放指定类型的元素。例如：
int[] array1 = new int[10];
String[] array2 =new String[10];

2、所有类的父类，默认为 Object 类。数组是否可以创建为 Object ？

代码示例

.>

此时，我们会发现：我们的数组由于类型是 Object 的类，说明什么类型都可以往数组里放。因此，我们 set 方法，接收的数据类型为 Object 类型，返回值也是Object 类型。
因为你不知道下一个返回的数据是什么类型的数据。
因此，导致了一个问题的出现，哪怕我们知道下一个数据类型，用相应的数据类型去接收也是不可以的。只能使用 Object 去接收。

只有进行强制类型转换，才能赋值。

结论

该代码，任何类型的数据都可以放入，但是取出需要强制类型转换。
虽然这个代码确定达到了通用的效果。但是！取出数据很麻烦。

由结论引出我们的泛型，将存在缺陷弥补。

我们来讲修整好的代码执行一下，看一下效果。

结果表明，编译阶段没有问题。而且有了泛型指定类型之后，在编译阶段会帮我们检查一波输入的数据类型，如果和指定类型不符，则会有错误提示。

结果表明，运行没有问题。
我们在来看看取出的数据的时候，有没有问题。

而且，不需要手动类型转换了。它会自动进行类型转换。
要向存储其他类型的数据也可以，只需要再去new MyArray 类，利用泛型去指定你想输入的数据类型。

取出数据。

泛型初步结论:

1、类名后的代表占位符，表示当前类时一个泛型类。
2、泛型类型的数数组，不能new/实例化。
3、基本数据类型，不能作为泛型类型的参数。要封装类。
4、类型后加入<数据类类型>，该类型只能处理规定的数据类型。
5、编译的时候，自动进行类型的检查
6、取出数据的时候，不需要类型转换。

泛型的主要目的：就是指定当前的“容器”，要持有什么类型的对象。让编译器去做检查。
此时，就把需要类型，作为参数传递。要什么类型，就传入什么类型。
以此达到灵活使用，却不会乱套的地步。

语法

语法一

class 泛型类名称<类型实参列表>{
  // 这里可以使用类型参数
}

//示例
class ClassName<T1,T2,.......Tn>{
    // 这里可以使用类型参数
}

语法二

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

泛型类的使用

语法

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

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

类型推导（Type inference）

编译器可以通过上下文推导出类型实参时，可以省略类型实参的填写。

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

裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型

相当于泛型没有其作用。又回到原点了。所以请记住：使用泛型类，记得加<类型实参>。

前半部分的概括小结

1、泛型是将数据类型参数化，进行传递。
2、使用表示当前类时一个泛型类。
3、泛型目前为止的优点：数据类型参数化，编译时自动进行类型的检查和转换。

泛型是如何编译的？

擦除机制

泛型到底是怎么编译的？这个问题是曾经的一个面试问题
泛型本身就是一个非常难的语法，需要理解好它，还是需要时间的！

下面我们就用通过实战来了解它是如何编译的。

通过命令： javap -c 查看字节码文件，发现所有的 T 都换成 Object。
即：在编译的过程当中，将所有的 T 替换 Object 这种机制，我们称为擦除机制。
Java 的泛型机制是在编译阶段实现的。
编译器生成的字节码在运行期间并不包含泛型的类型信息。

擦除机制的介绍

有关泛型擦除机制的文章截介绍：链接
这篇文章讲得非常清楚的。
我们摘取部分重要内容讨论

什么意思呢？我们在这里再解读一下。

如果这么去写，我们又会回到最初的问题。因为我们刚开始就是这么写的。
放入数据没有限制，太灵活了。拿出数据需要强制类型准换，太麻烦了。
现在我们就是使用反证法，来简单说明一下。
假设泛型类型的数组可以实例化：public T[] objects = new T[10]；

有的人可能会有疑问：不是说泛型在编译期间，会检查数据类型吗？为什么一开始不报错？
其实很简单：类型检查嘛，你指定类型参数是 String，它就认为 getArray 返回的数组类型就是String[] 类型，所以它不会报错。
还有一个因素：因为 public T[] objects = new T[10]；能成立的话，根据擦除机制：T = Object，那么就是说：这个数组它可以存储任何类型的元素。故：getArray 返回的数组元素类型可以五花八门的，我们凭什么认为 String[] 能接收？答案是不能的！
其实我们的这种写法： public T[] objects = (T[])new Object[10]；也是不安全的！
存在的问题也是一样的，数组的元素也有可能存储不同类型的元素。
有的人可能就会说：那搞了半天，这泛型不跟没有一样？答案：不是的！它起着一定提示作用，指定我们输入某种类型的数据。能够程度上避免我们犯错。
当然，并不说泛型就这点作用，这是因为此时使用泛型的方法，不是正确的。

那么，正确的方法又是怎么样？不知道大家有没有注意到上面那篇文章的部分截图最下面划线的地方。

通过Array.newInstance() 方法，向它转入参数，才能真正创建一个 T[] 类型的数组。
‘如果要创建一个泛型数组，记住一定是使用反射来创建的。
记住！不要傻里傻气说：原码里 ArrayList 底层的数组就是 Object类型。原码有它自己的处理方式，绝大部分人又不会涉及到 jdk 的开发，所以无足轻重。有兴趣的，自己去研究。

泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。
泛型只有上界，没有下界。另外，当泛型类没有指定边界时（class 泛型类名），默认是Object。

语法

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

示例

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

只接受 Number 的子类型作为E的类型实参（E 可以是 Number 或者 Number的子类）。这就叫做泛型上界。

实例

复杂示例 - 比较接口

public class MyArray<E extends Comparable<E>> {
...
}

&ensp；

实例 - 写一个泛型类，找出数组中的最大值

所以，此时我们需要实现 Comparator 或者 Comparable 接口，来比较大小。
通过 compareTo 方法来比较。

但是，你会发现没有与 Comparable 和 Comparator 相关的功能。
这是因为你怎么确定类型参数 T 它实现了 Comparable 或者 Comparator接口的方法？
没有办法确定！
来看怎么解决！

来看看实际效果

基本数据类型的包装类和 String 类都实现了 Comparable 接口

泛型方法

定义语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }
//  <类型形参列表> 一般只有在静态方法中，写在static后面

实例 - 非静态

实例 - 静态

细心的朋友发现，你在通过类名调用静态方法的时候，并没有指定类型啊。
为什么就可以通过呢？
其实，是省略了。来看下面的图

泛型中的父子类关系

public class MyArrayList<E> { ... }
// MyArrayList<Object> 不是 MyArrayList<Number> 的父类型
// MyArrayList<Number> 也不是 MyArrayList<Integer> 的父类型

理论上来说：Object 是所有类的父类。
至于为什么说： MyArrayList 不是 MyArrayList 的父类型， MyArrayList 也不是 MyArrayList 的父类型。这是因为这些类名后面的尖括号和里面的类型参数都会被擦除掉。

findMax方法里面的 T 会被擦成 Object，而<类型参数>会被完全擦除。
也就说：在JVM当中是没有泛型的概念的。
所以上面的 4个类时构成不了父子关系的。

通配符

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

通配符解决什么问题

通配符是用来解决泛型无法协变的问题。
协变指的就是如果 Student 是 Person 的子类，那么List 也应该是 List的子类。
但是泛型是不支持这样样子父子类关系的。
1、泛型 T 是指定的类型，一旦你传给了我就定下了。而通配符则更为灵活或者说是不确定，更多的是用于扩充参数的范围。
2、或者我们可以这样理解：泛型 T 就是一个变量，等着你将来传给它一个具体的类型；而通配符则是一种规定：规定你只传某一个范围的参数类型。【比如说整形 short、int 都是整形范围里的类型】

实例：假设现有一个 list，输出list当中的数据

代码1

泛型指定了某种类型，也就是说：类型参数 T 一定是将来指定的一个泛型参数。
public static<T> void printList1(ArrayList<T> list) {
   for (T x:list) {
     System.out.println(x);
   }
}

代码二

//代码2中使用了通配符，和代码1相比，此时传入printList2的数据类型，
//具体是什么数据类型，我们是不清楚的。这就是通配符。
// 这也是为什么 foreach 循环中，x 是 Object 类型，就是因为不确定数据类型，
public static void printList2(ArrayList<?> list) {
  for (Object x:list) {
    System.out.println(x);
  }
}

代码比较

效果图

从效果上来看：两者效果是一样的。
唯一的区别即使程序上的区别，print1 的T 一定是指定了某种数据类型的。接收还是用 T 去接收。
而 print2 使用了通配符？，指定了一个类型范围，虽然扩充了参数的范围，但同时也意味着无法确定具体类型，所以使用 Object 去接收读取的数据。

通配符上界

语法

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

示例 1

// 可以传入类型实参是 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>());

示例 2

Animal
Cat extends Animal
Dog extends Anima
Cat 和 Dog 都继承了 Animal，也就是说 Animal 是 Cat 和 Dog 的 父类，即 Cat 和 Dog是 Animal的子类。

根据上述关旭，写一个方法，打印一个存储了Animal 或者 Animal 子类的 list、

代码1

public static void print(List<Animal> list) {
}

但是这样写不可以解决这个问题，因为 print 的参数类型是 List list,就不能接收 List list。.
因为 List 是一个泛型，根据前面所讲 Cat 和 Dog 跟泛型的父类是不构成父子关系的。
所以说通配符的出现就是为解决这一类的问题（协变类型：父子类关系）。

代码2

public static <T extends Animal> void print2(List<T> list) {
  for (T animal : list) {
    System.out.println(animal);
  }
}

此时T类型是Animal的子类或者自己。该方法可以实现.
因为我们通过 extends Animal 确保了 T 是 Animal 的子类，或者本身。
这里是泛型上界

代码3 - 通配符实现

public static void print3(List<? extends Animal> list) {
   for (Animal ani : list) {
     System.out.println(ani);//调用谁的toString 方法？
   }
}

这方法比上一个方法更好。
通过利用通配符的上界，将类型参数限制为 Animal 或者 Animal 的子类。
所以在 foreach 循环，我们可以是使用 Animal 来接收读取的数据。
也就是只是传入 Cat 或者 Dog 都是可以的。
但是输出的时候，存入的如果是Cat ，那么输出的时候就会调用 Cat 的 toString 方法、
同理：Dog 的话，那么sout的时候就会调用 Dog 的toString 方法。
Animal 就调用 Animal 的 toString 方法。
注意！如果没有在通配符后面添加上界，那么foreach就需要使用 Object 类型去接收。

三个代码的区别

1、对于实现泛型的 print2 方法，对 T 进行了限制，只能是Animal 或者Animal 的子类（泛型上界），当传入Cat时，类型也就定下来了，就是Cat。
'2、对于通配符实现的print3方法，首先不用在static后面使用尖括号，其次相当于对Animal 进行了规定，允许你传入animal的子类。具体哪个子类，此时并不清楚。
【比如：传入了Cat，实际上声明的类型是 Animal，使用多态才能调用Cat的toString方法】

通配符的上界 - 父子类关系

// 需要使用通配符来确定父子类型
MyArrayList<? extends Number> 是 MyArrayList <Integer>或者 MyArrayList<Double>的父类类型
MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型

对于 MyArrayList<? extends Number>，我们只能传入 Number 或者 Number的子类。
而后面的 MyArrayList 或者 MyArrayList中的和，但是属于<? extends Number>的子类。
即：MyArrayList<? extends Number> 是 MyArrayList 或者 MyArrayList的父类类型

对于 MyArrayList<?> ，<?> 就相同与 Object了，Objet 是所有类的父类。
那么，MyArrayList<? extends Number>中的 <? extends Number> 就是它的子类了。
即：MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型

通配符的上界 - 特点

对于这个代码，我们思考：是否可以对这个List 进行写入？

答案是不可以！【具体原因注释写很清楚】
但是请记住：通配符的上界适合读取数据，不适合输入数据。’

通配符的下界

语法：

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

注意！通配符有下界，但是泛型没有下界。
通配符的上界与下界的区别就在于 extends + (上界) 与 super + (下界)
xtends + (上界) : 传参的类型只能是上界，或者上界的子类。
super + (下界)：传参的类型只能是下界，或者下界的父类。

示例

// 可以传入类型实参是 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>());

实例

附图 - 来自java 黑皮书

还是一开始说的那句话，不要较真，以看得懂代码为母的就行了。
能用到通配符，除非你被邀请参加开发 jdk，这个可能非常小。

包装类

这里我就不再多讲，看着我的这篇文章就行了！
List 接口相关知识 - ArrayList数据结构 - Java - 细节狂魔开头就讲了泛型和包装类。自行学习。

Genericity - 泛型 - Java - 细节狂魔

前言