小白学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并不是ArrayList