Java之泛型剖析

 泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。泛型提供了一个类型参数用来指示元素的类型。比如AarryList:
 ArrayList<Sting> strs = new ArrayList<String>();(根据多态性，前面的ArrayList<String>可以换成List<String>)。这样使代码有更好的可读性。

一个泛型类就是具有一个或多个类型变量的类。下面是一个简单的泛型类：

 public class Result<T> {
    private T first;
    private T second;

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }

    public static <T> T getObj(Class<T> cls) throws IllegalAccessException, InstantiationException {
        return cls.newInstance();
    }
}

Result类中引入类型变量T，用尖括号(<>)括起来，并放在类后面。泛型类可以有多个类型变量，其中第一个域和第二个域可以有不同的类型：public class Result<T, U>{....}。类定义中的类型变量指定方法的返回类型以及域和局部变量的名字。
上面的例子中还定义了一个泛型方法getObj()。当然泛型方法也可以在普通类中定义。

类型变量的限定

有时，类或方法需要对类型加以约束

public class ArrayTest {
    public static <T extends Comparable> T min(T[] a) {
        if (a == null || a.length == 0) {
            return null;
        }
        T temp = a[0];
        for (int i = 1; i < a.length; ++i) {
            if (temp.compareTo(a[i]) > 0) {
                temp = a[i];
            }
        }
        return temp;
    }
}

这里对T的类型限制为实现了Comparabe接口的类。之所以这样做是因为，只有实现了Comparabe接口的类才会实现compareTo()方法。程序才能正确编译执行。
（这里需要注意的是Comparabe接口本身就是一个泛型类型）。
<T extends BoundingType>表示T应该是绑定类型（BoundingType）的子类型。T和绑定的类型可以是类也可以是接口。（均使用extends关键字）。
一个类型变量或通配符可以有多个限定，例如：
T extends Comparable & Serializable
限定类型用“&”分隔，而逗号用来分隔类型变量。注意点：Java的继承中，可以根据需要拥有多个接口超类型，但限定至多有一个类。如果一个类作为限定，它必须是限定列表中的第一个。

泛型的擦除

虚拟机没有泛型类型对象，所有类型都属于普通类。当定义一个泛型类型时，都自动提供了一个相应的原始类型。原始类型就是删去类型参数后的泛型名。擦除类型变量，并替换为限定类型。
原始类型用第一个限定的类型变量来替换，如果没有给定限定就用Object替换。比如上面的例子，因为T无类型限制，所以会被用Object代替。例子如下：

public class ResultSecond<T extends Comparable & Serializable> implements Serializable {
    private T first;
    private T second;

    public ResultSecond(T first, T second) {
        if (first.compareTo(second) > 0) {
            this.first = first;
            this.second = second;
        } else {
            this.first = second;
            this.second = first;
        }
    }
}

原始类型如下:

public class ResultSecond {
    private Comparable first;
    private Comparable second;

    public ResultSecond(Comparable first, Comparable second) {
        if (first.compareTo(second) > 0) {
            this.first = first;
            this.second = second;
        } else {
            this.first = second;
            this.second = first;
        }
    }
}

几个注意点

1、不能用基本类型实例化类型参数。
因此没有Result<int>,只有Result<Integer>。原因是类型擦除。擦除后，Result类含有Object类型的域，而Object不能存储int值。
2、运行时类型查询只适用于原始类型。
虚拟机中的对象总有一个特定的非泛型类型。因此所有的类型检查只产生原始类型。例如：if (a instanceof Result<T>)，仅仅只是测试a是否是任意类型的一个Result。
3、不能创建参数化类型的数组。
不能实例化参数化类型的数组。
例如：Result<String>[] result = new Result<String>[5];这是不被允许的，因为擦除之后，result类型就是Result[]类型。
这里只是不允许创建数组，但是声明为Result<String>[]的变量仍是合法的。不过不能用new Result<String>[10]初始化这个变量。
4、不能实例化类型变量。不能使用new T(...)，new T[...]。
5、泛型类的静态上下文类型变量无效。即不能在静态域或方法中引用类型变量。
6、不能抛出或捕获泛型类的实例
7、注意擦除后的冲突。