小白学Java：老师！泛型我懂了！
泛型概述
使用泛型机制编写的程序代码要比哪些杂乱地使用Object变量，然后再进行强制类型转换地代码具有更好的安全性和可读性。
以上摘自《Java核心技术卷一》
在谈泛型的定义之前，我先举一个简单又真实的例子：如果我想定义一个容器，在容器中放同一类的事物，理所当然嘛。但是在没有泛型之前，容器中默认存储的都是Object类型，如果在容器中增加不同类型的元素，都将会被接收，在概念上就不太符合了。关键是放进去不同元素之后，会造成一个很严重的情况：在取出元素并对里面的元素进行对应操作的时候，就需要复杂的转型操作，搞不好还会出错，就像下面这样：
//原生类型
ArrayList cats = new ArrayList();
cats.add(new Dog());
cats.add(new Cat());
for (int i = 0; i < cats.size(); i++) {
//下面语句类型强转会发生ClassCastException异常
((Cat) cats.get(i)).catchMouse();
}
而泛型又是怎么做的呢？通过尖括号<>里的类型参数来指定元素的具体类型。
ArrayList<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new SkyBarking());
dogs.add(new Snoopy());
dogs.add(new Cat());//编译不通过
//向上转型,另外两个是Dog的子类对象
for(Dog d:dogs){
System.out.println(d);
}
至此，泛型优点显而易见：
- 可读性：很明显嘛，一看就知道是存着一组Dog对象。
- 安全性：如果类型不符，编译不会通过，因此不再需要进行强制转换。
妙啊，从中我们可以体会泛型的理念：泛型只存在编译器，宁可让错误发生在编译期，也不愿意让程序在运行时出现类型转换异常。 因为bug发生在编译期更容易去找到并修复。 除此之外：
- 可将子类类型传入父类对象的容器之中，向上转型。
- 不必纠结对象的类型，可用增强for循环实现遍历。
定义泛型
再次强调，所谓泛型，即参数化类型，就是只有在使用类的时候，才把类型确定下来，相当的灵活。
泛型类的定义
class Element<T>{
private T value;
Element(T value){
this.value = value;
}
public T getvalue() {
return this.value;
}
}
- 引入类型变量T（按照规范，也可以有多个，用逗号隔开），并用
<>扩起，放在类名后面。 - 其实就是可以把T假想成平时熟悉的类型，这里只不过用个符号代替罢了。
Element<String> element = new Element<>("天乔巴夏");
System.out.println(element.getvalue());
- 使用泛型时，用具体类型（只能是引用类型）替换类型变量T即可。泛型其实可以堪称普通类的工厂。
- 泛型接口的定义与类定义类似，就暂且不做赘述。
泛型方法的定义
class ParaMethod {
public static <T> T getMiddle(T[] a) {
return a[a.length/2];
}
}
- 注意该方法并不是在泛型类中所定义，而是在普通类中定义的泛型方法。
- 类型变量T放在修饰符的后面，返回类型的前面，只是正好我们这边返回类型也是T。
int m = ParaMethod.getMiddle(new Integer[]{1,2,3,4,5});
//返回Integer类型，自动拆箱
System.out.println(m);//3
类型变量的限定
我们上面讲到，泛型拥有足够的灵活性，意味着我传啥类型，运行的时候就是啥类型。但是，实际生活中，我要是想对整数类型进行操作，不想让其他类型混入，怎么办呢？对了，加上类型限定。
public static <T extends Number> T getNum(T num) {
return num;
}
- 定义格式：
修饰符 <T extends 类型上限> 返回类型 方法名 参数列表，如上表示对类型变量的上限进行限定，只有Number及其子类可以传入。 - 规定类型的上限的数量最多只能有一个。
- 既然类的定义是这样子，那大胆猜测一下，定义接口上线是不是就应该用
implements关键字呢？答案是：否！接口依旧也是extends。
public static <T extends Comparable & Serializable> T max(T[] a) {
if (a == null || a.length == 0) return null;
T maximum = a[0];
for (int i = 1; i < a.length; i++) {
if (maximum.compareTo(a[i]) < 0) maximum = a[i];
}
return maximum;
}
- 需要注意的是：如果允许多个接口作为上限，接口可以用&隔开。
- 如果规定上限时，接口和类都存在，类需要放在前面，
<T extends 类&接口>。 - 没有规定上限的泛型类型可以视为:
<T extends Object>。
原生类型与向后兼容
使用泛型类而不指定具体类型，这样的泛型类型就叫做原生类型（raw type）,用于和早期的Java版本向后兼容，毕竟泛型JDK1.5之后才出呢。其实我们在本篇开头举的例子就包含着原生类型，ArrayList cats = new ArrayList();。
ArrayList cats = new ArrayList();//raw type
它大致可以被看成指定泛型类型为Object的类型。
ArrayList<Object> cats = new ArrayList<Object>();
注意：原生类型是不安全的！因为可能会引发类型转换异常，上面已经提到。所以我们在使用过程中，尽量不要使用原生类型。
通配泛型
我们通过下面几个例子，来详细总结通配类型出现的意义，以及具体的用法。
非受限通配
如果我想定义一个方法，让它接收一个集合，不关注集合中元素的类型，并把集合中的元素打印出来，应该怎么办呢？
上面谈到泛型，你可能会这样写，让方法接收一个Object的集合，这样子你传进来啥我都接，完成之后美滋滋，一调试就不对了：
public static void print(ArrayList<Object> arrayList){
//错误！：arrayList.add(5);
for(int i = 0;i< arrayList.size();i++){
System.out.println(arrayList.get(i));
}
}
ArrayList<Integer> arr = new ArrayList<>();
print(arr);
究其原因：Integer是Object的子类的确没错，但是ArrayList