Java generics

泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子：

class Wrapper<T> {
    final T data;

    Wrapper(T data) {
        this.data = data;
    }
}

有一些可能不是特别常用的Generics，我们来简单看一下。

Bounded Generics

Multiple bound

如果一个类继承了多个接口，是这样的写法：

interface I {}
interface M {}
abstract class C {}

class Foo extends C implements I,M {}

假如一个方法的泛型参数包含多个Bound，则要这样写了：

<T extends I & M> void bar(T arg){}
<T extends C> void ooo(T arg){}
<T extends C & I & M> void xxx(T arg){}

Unbounded wildcards

使用 ? 修饰符可以用作类型转换，List<?> 意味着是一个未知类型的List，可能是`List<A>` 也可能是`List`

private final List<String> strList = Arrays.asList("Hello", "World!");
private final List<Integer> intList = Arrays.asList(1, 2, 3);
private final List<Float> floatList = Arrays.asList(1.1f, 2.1f, 3.1f);
private final List<Number> numberList = Arrays.asList(1, 1.0f, 3000L);

public void cast() {
    List<?> unknownList = null;
    unknownList = strList;
    unknownList = intList;
    unknownList = floatList;
    unknownList = numberList;

    for (int i = 0; i < unknownList.size(); i++) {
        // Number item = unknownList.get(i); wrong! 
        Object item = unknownList.get(i);
        System.out.println(item + "(" + item.getClass() + ")");
    }
}
/* output
1(class java.lang.Integer)
1.0(class java.lang.Float)
3000(class java.lang.Long)
*/

Upper bounded wildcards

public static double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}
//...
sumOfList(Arrays.asList(1, 2, 3));
sumOfList(Arrays.asList(1.0f, 2.0f, 3.0f));

Lower bounded wildcards

public static void addNumbers(List<? super Number> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
        list.add(1.0f);
    }
}
addNumbers(new ArrayList<Number>());

Type erase

Type erase process

Java的泛型是编译时有效的，在运行时，所有泛型参数会被编译器擦除。擦除的规则如下：

• 如果参数是有Bound的，则会替换成这个Bound
• 如果是Unbounded，则会替换成Object

如下所示：

public class Node<T> {                         // public class Node {
    private T data;                            //     private Object data;
    private Node<T> next;                      //     private Node next;
    public Node(T data, Node<T> next) {        //     public Node(Object data, Node next) {
        this data = data;                      //         this data = data;
        this next = next;                      //         this next = next;
    }                                          //     }
                                               // 
    public T getData() { return data; }        //    	public Object getData() { return data; }
}                                              // }

public class Node<T extends Comparable<T>> {   // public class Node {
    private T data;                            //     private Comparable data;
    private Node<T> next;                      //     private Node next;
    public Node(T data, Node<T> next) {        //     public Node(Comparable data, Node next) {
        this.data = data;                      //         this.data = data;
        this.next = next;                      //         this.next = next;
    }                                          //     }
                                               // 
    public T getData() { return data; }        //     public Comparable getData() { return data; }
}                                              // }

Bridge method

按照上面的擦除也会带来问题。考虑下面的例子，如果有一个子类：

public class MyNode extends Node<Integer> {       // public class MyNode extends Node {
    public MyNode(Integer data) { super(data); }  //     public MyNode(Integer data) { super(data); }
                                                  // 
    public void setData(Integer data) {           //     public void setData(Integer data) {
        System.out.println("MyNode.setData");     //         System.out.println("MyNode.setData");
        super.setData(data);                      //         super.setData(data);
    }                                             //     }
}                                                 // }

然后，我们考虑如下的代码：

MyNode mn = new MyNode(5);                     // MyNode mn = new MyNode(5);
Node n = mn;                                   // Node n = (MyNode)mn;
n.setData("Hello");                            // n.setData("Hello");
Integer x = mn.data;                           // Integer x = (String)mn.data;

这里调用setData则会参数类型不能匹配。为了解决这个问题，Java编译器会生成一个Bridge method:

public void setData(Object data) {
    setData((Integer) data);
}

Q&A

List\<?\> vs List\<Object\>

>It's important to note that List<Object> and List<?> are not the same. You can insert an Object, or any subtype of >Object, into a List<Object>. But you can only insert null into a List<?>.

extends vs super

实际上泛型仅仅是为了做一个编译时的检查，从逻辑上确保程序是类型安全的。假设我们有这样的类定义： Object->Parent->T->Child 我们有这样几种写法：

• ```List<?>``` 代表一种未知类型的List，可能是```List<Object>```，也可能是```List<Child>```，都可以
• ```List<? extends T>``` 代表T或者T的子类的List，可以是```List<T>```，也可以是```List<Child> ```
• ```List<? super T>``` 代表T或者T的父类的List，可以是```List<T>，List<Parent>，List<Object>```

我们有一个事实就是，Child是一定可以转化T或者Parent的，但是一个T不一定能转化成Child，因为可能会是别的子类。 比如我们现在做两个列表的拷贝，

public static <T> void copy(List dest, List src)

想实现从一个列表拷贝到另一个列表，比如

List<Parent> parents;
List<T> ts;
List<Child> childs;

基于上面说的类的继承的事实，ts/childs显然是可以转化成parents的，但是ts无法确保能转化成childs。因此我们的拷贝方法要这样定义：

public class Collections { 
  public static <T> void copy  
  ( List<? super T> dest, List<? extends T> src) {  // uses bounded wildcards 
      for (int i=0; i<src.size(); i++) 
        dest.set(i,src.get(i)); 
  } 
}

因为在desc.set()方法中，需要的是一个能够转化为T的对象的，src中<? extends T> 保证了src中的元素一定是一个T。

See also:

• Lesson: Generics (Updated)