Java 泛型 介绍

　　为什么需要泛型？

public class GenericTest {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

　　定义一个List类型的集合，先增加2个String类型的值，再增加1个Integer类型的值。这是完全允许的，因为此时list默认的元素类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值，出现上面1中的错误。编译时正常，而运行时出现java.lang.ClassCastException。因此，此类错误在编码过程中不易被发现。

　　增加一个对象到集合中，集合不会记住此对象的类型。从集合中取出此对象时，该对象的编译时类型（表面类型）是Object类型，但其运行时类型（实际类型）是本身类型。因此，上面1处取出集合元素时需要人为地强制类型转换到具体的目标类型，容易出现java.lang.ClassCastException。

　　使用泛型达到这一目的——使集合能够记住集合内元素类型，只要编译时不出现问题，运行时就不会出现java.lang.ClassCastException。

　　什么是泛型？

　　泛型指参数化类型。将原来的具体类型参数化，类似于方法中的形参，类型定义成了参数形式即类型形参，然后在使用时传入具体的类型即类型实参。

　　使用泛型来修改上面的代码：

public class GenericTest {

    public static void main(String[] args) {
        /*
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);
        */

        List<String> list = new ArrayList<String>();
        list.add("qqyumidi");
        list.add("corn");
        //list.add(100);   // 1  提示编译错误

        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i); // 2
            System.out.println("name:" + name);
        }
    }
}

　　采用泛型写法后，在上面1处增加1个Integer对象时会出现编译错误。List<String>中String是类型实参，直接限定了集合中只能含有String类型的元素，从而上面2处无需进行强制类型转换。也就是说，集合记住了元素的类型，编译器确认了它是String类型。

　　List接口的定义：

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    void clear();

    boolean equals(Object o);

    int hashCode();

    E get(int index);

    E set(int index, E element);

    void add(int index, E element);

    E remove(int index);

    int indexOf(Object o);

    int lastIndexOf(Object o);

    ListIterator<E> listIterator();

    ListIterator<E> listIterator(int index);

    List<E> subList(int fromIndex, int toIndex);
}

　　List接口采用了泛型定义，<E>中的E表示类型形参，用于接收具体的类型实参。出现E的地方均表示接收外部相同的类型实参。

　　作为List接口的实现类，ArrayList的定义形式：

public class ArrayList<E> extends AbstractList<E> 
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    public E get(int index) {
        rangeCheck(index);
        checkForComodification();
        return ArrayList.this.elementData(offset + index);
    }
    
    //...省略掉其他具体的定义过程

}

　　

　　自定义泛型接口、泛型类和泛型方法

　　泛型类和泛型方法定义实例：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        System.out.println("name:" + name.getData());
    }

}

class Box<T> {

    private T data;

    public Box() {

    }

    public Box(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

}

　　常见的如T、E、K、V等形式的参数通常表示类型形参，接收外部传入的类型实参。<T>表示泛型方法，T是方法的返回类型。

　　对于传入的不同类型实参，相应生成的对象实例的类型是否一样？

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);

        System.out.println("name class:" + name.getClass());      // com.qqyumidi.Box
        System.out.println("age class:" + age.getClass());        // com.qqyumidi.Box
        System.out.println(name.getClass() == age.getClass());    // true

    }

}

　　在使用泛型类时，虽然传入了不同的类型实参，但没有生成不同的类型。可以传入不同类型实参的泛型类在内存上只有一个，即原来的基本类型（本实例中为Box）。因为泛型只是作用于编译阶段，通过编译的class文件是不包含任何泛型信息的。

　　类型通配符

　　根据上面的实例，Box<Number>和Box<Integer>实际上都是Box类型。Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？

public class GenericTest {

    public static void main(String[] args) {

        Box<Number> name = new Box<Number>(99);
        Box<Integer> age = new Box<Integer>(712);

        getData(name);
        
        //The method getData(Box<Number>) in the type GenericTest is 
        //not applicable for the arguments (Box<Integer>)
        getData(age);   // 1

    }
    
    public static void getData(Box<Number> data){
        System.out.println("data :" + data.getData());
    }

}

　　上面1处出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。Box<Number>不能视为Box<Integer>的父类。

　　为什么？

public class GenericTest {

    public static void main(String[] args) {

        Box<Integer> a = new Box<Integer>(712);
        Box<Number> b = a;  // 1
        Box<Float> f = new Box<Float>(3.14f);
        b.setData(f);        // 2

    }

    public static void getData(Box<Number> data) {
        System.out.println("data :" + data.getData());
    }

}

class Box<T> {

    private T data;

    public Box() {

    }

    public Box(T data) {
        setData(data);
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

　　上面1处和2处肯定会出现错误提示。使用反证法来说明：

　　假设Box<Number>可以视为Box<Integer>的父类，上面1处和2处将不会有错误提示。通过getData方法取出的数据到底是什么类型？Integer? Float? 还是Number？由于编程过程的顺序不可控性，在必要的时候判断类型，进行强制类型转换。这与泛型的理念矛盾。因此，Box<Number>不能视为Box<Integer>的父类。

　　类型通配符用来表示Box<Integer>和Box<Number>的父类的引用类型。

　　类型通配符使用?代替具体的类型实参。Box<?>是Box<Integer>和Box<Number>等所有Box<类型实参>的父类。

　　实例如下：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

}

　　限制类型实参只能是Number类及其子类，需要用到类型通配符上限：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
        
        //getUpperNumberData(name); // 1
        getUpperNumberData(age);    // 2
        getUpperNumberData(number); // 3
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }
    
    public static void getUpperNumberData(Box<? extends Number> data){
        System.out.println("data :" + data.getData());
    }

}

　　上面1处调用会出现错误，而上面2处和3处调用正常。

　　总之，类型通配符上限为Box<? extends Number>形式，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限相反。

　　注意：Java中没有泛型数组。

　　参考资料

　　Java总结篇系列：Java泛型

　　<T>和T的区别