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 都是整形范围里的类型】
代码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) {
...
}
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
