java泛型探索——小特性

泛型特性（小篇幅）

1. 補充介紹一些常見的泛型特性：

    類型參數T可以是recursive（類似遞歸性），它的邊界可以是類型參數是自身的介面或類。

如我實現尋找最大值的方法，可以這麼寫:

public static <T extends Comparable<T>> T max(Collection<T> coll) {
    T candidate = coll.iterator().next();
    for (T elt : coll) {
        if(candidate.compareTo(elt) < 0)
            candidate = elt;
    }
    return candidate;
}

    泛型多邊界（Multiple Bounds）

    public static<S extends Readable & Closeable, T extends Appendable & Closeable> 
    void copy(S src ,T trg, int size) throws IOException {
        try {
         CharBuffer buf = CharBuffer.allocate(size);
         int i = src.read(buf);
         while (i >= 0) {
             buf.flip();
             trg.append(buf);
             buf.clear();
             i = src.read(buf);
         }
        } finally {
            src.close();
            trg.close();
        }
    }

2. Bridges特性

對於泛型介面而言，如Comparable<T>，在編譯時會插入額外的方法，這些方法被叫做bridges。

在沒有泛型以前，Comparable介面是怎麼實現的呢？ 我們省略一些代碼，簡寫一下，代碼如下：

interface Comparable {
    public int compareTo(T o); }
class Integer implements Comparable { 
    private final int value;
    public Integer(int value) { 
        this.value = value; 
    } 
    public int compareTo(Integer i) {
        return (value < i.value) ? -1 : (value == i.value) ? 0 : 1; 
    }

    public int compareTo(Object o) {
        return this.compareTo((Integer)o);
    }
}

我們將 compareTo(Object o)方法稱為bridge。

泛型介面在jvm編譯過程中，就會產生bridge方法，我們就以Comparable<T>為例：

interface Comparable<T> {
    public int compareTo(T o); }
class Integer implements Comparable<Integer> { 
    private final int value;
    public Integer(int value) { 
        this.value = value; 
    } 
    public int compareTo(Integer i) {
        return (value < i.value) ? -1 : (value == i.value) ? 0 : 1; 
    }
}

我們以Integer為例，它實現了Comparable介面，我們通過反射查看有幾個compareTo方法，see：

for (Method m : Integer.class.getMethods()) {
     if (m.getName().equals("compareTo"))
     System.out.println(m.toGenericString());
}

它的輸出結果是這樣的：

public int java.lang.Integer.compareTo(java.lang.Integer)
public int java.lang.Integer.compareTo(java.lang.Object)

可以看出確實是這樣的。至於為什麼會這樣，接下來慢慢介紹，先留個坑，我們可以先看看bridge方法有什麼用處。

3. Covariant Overriding （協變覆蓋）

　在java1.4的時候，方法的覆蓋必須嚴格意義上的參數類型和返回類型相同，而java1.5以後，方法的覆蓋，只需要參數列表相同，而參數列表是一樣的，如果返回類型

是父類的子類，那這個子類的方法也可以overriding父類的方法。

  我們以clone方法為例，在Object類中：

class Object {
    ...
    public Object clone() { ... }
}

而在Point類中：

class Point extends Object {
    public int x;
    public int y;
    public Point(int x,int y) {
        this.x = x;
        this.y = y;
    }
    public Point clone() {
        return new Point(x,y);
    }
}

在java1.4之前，上面的clone方法無法覆蓋Object的clone方法，但從java1.5開始就可以這麼寫，這是為什麼呢，還是bridge的功勞：

我們在利用反射看看，Point類中有幾個clone方方法：

for(Method m : Point.class.getMethods()) {
   if(m.getName().equals("clone"))
System.out.println(m.toGenericString());
}

輸出如下：
output
public Point Point.clone()
public java.lang.Object Point.clone() throws java.lang.CloneNotSupportedException

java.lang.Object Point.clone()方法只是簡單的調用了Point.clone()方法，就這樣實現了覆蓋。

好了，這些是泛型的零散知識點，先介紹一下，後面繼續todo。