在從Java in a Nutshell,5th edith中摘錄的兩部部分中的第一部分，David Flanagan描述了如何使用泛型。這部分，David Flanagan將具體告訴你如何創(chuàng)建自己的泛型和泛型方法，并且以Java核心API很多重要的泛型作為結束總結 

Java中的泛型 第二部分
作者：David Flanagan
譯者:glorywine

版權聲明：任何獲得Matrix授權的網站，轉載時請務必以超鏈接形式標明文章原始出處和作者信息及本聲明
作David Flanagan;glorywine
原文地址: http://www./pub/a/onjava/excerpt/javaian5_chap04/index1.html
中文地址:http://www./resource/article/43/43914_Generic_Types.html
關鍵詞： Java Generic Types

編者注：在從Java in a Nutshell,5th edith中摘錄的兩部部分中的第一部分，David Flanagan描述了如何使用泛型。這部分，David Flanagan將具體告訴你如何創(chuàng)建自己的泛型和泛型方法，并且以Java核心API很多重要的泛型作為結束總結。

創(chuàng)建泛型和泛型方法
創(chuàng)建一個簡單的泛型是非常容易的。首先，在一對尖括號(< >)中聲明類型變量，以逗號間隔變量名列表。在類的實例變量和方法中，可以在任何類型的地方使用那些類型變量。切記，類型變量僅在編譯時存在，所以不能使用instanceof和new這類運行時操作符來操作類型變量。

讓我們以一個簡單的例子來開始這部分的學習，而后將精簡這個例子。這段代碼定義了一個樹形數據結構，使用類型變量V代表存儲在各個樹結點中的值。

import java.util.*;
/**
 * A tree is a data structure that holds values of type V.
 * Each tree has a single value of type V and can have any number of
 * branches, each of which is itself a Tree.
 */
public class Tree<V> {
    // The value of the tree is of type V.
    V value;

    // A Tree<V> can have branches, each of which is also a Tree<V>

    List<Tree<V>> branches = new ArrayList<Tree<V>>();

    // Here‘s the constructor.  Note the use of the type variable V.
    public Tree(V value) { this.value = value; }

    // These are instance methods for manipulating the node value and branches.
    // Note the use of the type variable V in the arguments or return types.
    V getValue() { return value; }
    void setValue(V value) { this.value = value; }
    int getNumBranches() { return branches.size(); }
    Tree<V> getBranch(int n) { return branches.get(n); }
    void addBranch(Tree<V> branch) { branches.add(branch); }
}

正如你所看到的，命名一個類型變量習慣于一個大寫字母。使用一個字母可以同現實中那些具有描述性的，長的實際變量名有所區(qū)別。使用大寫字母要同變量命名規(guī)則一致，并且要區(qū)別于局部變量，方法參數，成員變量，而這些變量常常使用一個小寫字母。集合類中，比如java.util中常常使用類型變量E代表“Element type”。T和S常常用來表示范型變量名（好像使用i和j作為循環(huán)變量一樣）。

注意到，當一個變量被聲明為泛型時，只能被實例變量和方法調用（還有內嵌類型）而不能被靜態(tài)變量和方法調用。原因很簡單，參數化的泛型是一些實例。靜態(tài)成員是被類的實例和參數化的類所共享的，所以靜態(tài)成員不應該有類型參數和他們關聯。方法，包括靜態(tài)方法，可以聲明和使用他們自己的類型參數，但是，調用這樣一個方法，可以被不同地參數化。這些內容將在本章后面談到。

類型變量綁定
上面例子中的Tree<V>中的類型變量V是不受約束的：Tree可以被參數化為任何類型。以前我們常常會設置一些約束條件在需要使用的類型上：也許我們需要強制一個類型參數實現一個或多個接口，或是一個特定類的子類。這可以通過指明類型綁定來完成。我們已經看到了統(tǒng)配符的上界，而且使用簡單的語法可以指定一般類型變量的上界。后面的代碼，還是使用Tree這個例子，并且通過實現Serializable和Comparable來重寫。為了做到這點，例子中使用類型變量綁定來確保值類型的Serializable和Comparable。

import java.io.Serializable;
import java.util.*;

public class Tree<V extends Serializable & Comparable<V>>
    implements Serializable, Comparable<Tree<V>>

{
    V value;
    List<Tree<V>> branches = new ArrayList<Tree<V>>();

    public Tree(V value) { this.value = value; }

    // Instance methods
    V getValue() { return value; }
    void setValue(V value) { this.value = value; }
    int getNumBranches() { return branches.size(); }
    Tree<V> getBranch(int n) { return branches.get(n); }
    void addBranch(Tree<V> branch) { branches.add(branch); }

    // This method is a nonrecursive implementation of Comparable<Tree<V>>

    // It only compares the value of this node and ignores branches.
    public int compareTo(Tree<V> that) {
        if (this.value == null && that.value == null) return 0;
        if (this.value == null) return -1;
        if (that.value == null) return 1;
        return this.value.compareTo(that.value);
    }

    // javac -Xlint warns us if we omit this field in a Serializable class
    private static final long serialVersionUID = 833546143621133467L;
}

一個類型變量的綁定是通過extends后的名字和一個類型列表（這可以是參數化的，就像Comparable一樣）表達的。注意當有不止一個綁定時，就像上面例子中的，綁定的類型要用&作為分隔符，而不是使用逗號。都后用來分隔類型變量，如果用來分隔類型變量綁定，就會模棱兩可。一個類型變量可以有任何數量的綁定，包括任何數量的借口和至多一個類。

范型中的通配符
上一章的例子中我們看到了通配符和控制參數化類型的通配符綁定。這些在范型中同樣非常有用。當前設計的Tree要求每個節(jié)點有相同類型的值，V。也許這樣太嚴格了，也許我們應該讓Tree的branches能夠存放V的子類而不全是V。這個版本的Tree（刪除了Comparable和Serializable接口的實現）這樣做會更靈活。

public class Tree<V> {
    // These fields hold the value and the branches
    V value;
    List<Tree<? extends V>> branches = new ArrayList<Tree<? extends V>>();

    // Here‘s a constructor
    public Tree(V value) { this.value = value; }

    // These are instance methods for manipulating value and branches
    V getValue() { return value; }
    void setValue(V value) { this.value = value; }
    int getNumBranches() { return branches.size(); }
    Tree<? extends V> getBranch(int n) { return branches.get(n); }
    void addBranch(Tree<? extends V> branch) { branches.add(branch); }
}

通配符綁定允許我們在枝節(jié)點上增加一個Tree<Integer>，比如，一個樹枝Tree<Number>：

Tree<Number> t = new Tree<Number>(0);  // Note autoboxing
t.addBranch(new Tree<Integer>(1));     // int 1 autoboxed to Integer

通過getBranch()查詢樹枝，而樹枝的返回類型不知道，所以必須使用統(tǒng)配符來表達。接下來的兩個是合法的，但第三個不是：

Tree<? extends Number> b = t.getBranch(0);
Tree<?> b2 = t.getBranch(0);
Tree<Number> b3 = t.getBranch(0);  // compilation error

當我們這樣來查詢一個樹枝時，不能精確確定它的返回類型，但是存在類型的上限，所以，我們可以這樣做：

Tree<? extends Number> b = t.getBranch(0);
Number value = b.getValue();

那我們不能做什么呢？設定樹枝的值，或者在原有的樹枝上添加新的樹枝。早前章節(jié)解釋的，上界的存在不會改變返回值的類型不可知，編譯器沒有足夠的信息讓我們安全的給setValue()或者一個樹枝（包括值類型）的addBranch()傳遞一個值。下面的兩行代碼都是非法的：

b.setValue(3.0); // Illegal, value type is unknown
b.addBranch(new Tree<Double>(Math.PI));

這個例子在設計時找到了一個平衡點：使用綁定通配符使得數據結構更加靈活，但是減少了安全使用其中方法的可能。這個設計是好是壞就要根據上下文聯系了。通常，好的范型設計是非常困難的。幸運的是，大多我們要使用的已經在java.util包中設計好了，而不用我們自己再去設計。

范型方法
　　正如前面說的，范型只能被實例成員調用，而不是靜態(tài)成員。同實例方法一樣，靜態(tài)方法也可以使用通配符。盡管靜態(tài)方法不能使用包含他們的類中的類型變量，但是他們可以聲明自己的類型變量。當一個方法聲明了自己的類型變量，就叫做范型方法。

這里有一個要添加到Tree中的靜態(tài)方法。他不是一個范型方法，但是使用了綁定的通配符，就好像先前我們看到的sumList()一樣：

/** Recursively compute the sum of the values of all nodes on the tree */
public static double sum(Tree<? extends Number> t) {
    double total = t.value.doubleValue();
    for(Tree<? extends Number> b : t.branches) total += sum(b);
    return total;
}

　　通過通配符的上界綁定，聲明自己的類型變量來重寫這個方法：

public static <N extends Number> double sum(Tree<N> t) {
    N value = t.value;
    double total = value.doubleValue();
    for(Tree<? extends N> b : t.branches) total += sum(b);
    return total;
}

　　范型的sum()不比通配符版本的簡單，而且聲明變量并沒有讓我們獲得什么。這種情況下，通配符方案要比范型方法更有效，當一個類型變量用來表達兩個參數之間或者參數和返回值之間的關系時，范型方法才是需要的。請看下面的例子：

// This method returns the largest of two trees, where tree size
// is computed by the sum() method.  The type variable ensures that 
// both trees have the same value type and that both can be passed to sum().
public static <N extends Number> Tree<N> max(Tree<N> t, Tree<N> u) {
    double ts = sum(t);
    double us = sum(u);
    if (ts > us) return t;
    else return u;
}

　　

這個方法使用類型變量N來約束參數和返回值有相同類型，并且參數是Number或者他的子類。

　　使得參數具有相同類型也許是有爭議的，應該讓我們能調用max()不論是Tree<Integer>或者Tree<Double>。一種方法是使用兩個不相干的類型變量來表示兩個不相干的值類型。注意，我們不能在方法的返回時使用變量而必須使用通配符：

public static <N extends Number, M extends Number>
    Tree<? extends Number> max(Tree<N> t, Tree<M> u) {...}

　　既然兩個類型變量N和M沒有任何聯系，而且每個僅在簽名的時候使用，他們沒有提供比通配符更多的好處，這種方法最好這樣寫：

public static Tree<? extends Number> max(Tree<? extends Number> t,
                                         Tree<? extends Number> u) {...}

所有在這里的范型方法都是靜態(tài)的，這并不是必須的，實例方法也可以聲明自己的類型變量。

調用范型方法
當你使用范型時，必須指定實際類型參數來代替相應的類型變量。但這些對范型方法有些不同：編譯器總是能計算出基于你所傳遞的參數的相應范型方法參數?？紤]一下上面定義的max()，作為例子：

public static <N extends Number> Tree<N> max(Tree<N> t, Tree<N> u) {...}

當你調用這個方法時，不需要指明N，因為N是隱含地由t和u指明。在后面的代碼中，編譯器決定N為Integer：

Tree<Integer> x = new Tree<Integer>(1);
Tree<Integer> y = new Tree<Integer>(2);
Tree<Integer> z = Tree.max(x, y);

編譯器判斷范型方法的參數類型稱為類型推斷。類型推斷是相對于知覺推斷的。而實際編譯器的實現方法是一種非常復雜的過程，超過了這本書的討論范圍。更多的細節(jié)在The Java Language Specification, Third Edition的第十五章。
讓我們看一個更加復雜的類型推斷，考慮一下這個方法：

public class Util {
    /** Set all elements of a to the value v; return a. */
    public static <T> T[] fill(T[] a, T v) {
        for(int i = 0; i < a.length; i++) a[i] = v;
        return a;
    }
}

這里有兩個該方法的調用：

Boolean[] booleans = Util.fill(new Boolean[100], Boolean.TRUE);
Object o = Util.fill(new Number[5], new Integer(42));

在第一個例子中，編譯器可以輕松的推斷出T是Boolean類型，第二個例子中，編譯器判斷T是Number。
在非常罕見的情況下，你可能會顯示的指明范型方法的參數類型。有時候這是必要的，比如，當范型方法不需要參數時?？紤]一下java.util.Collections.emptySet()：返回一個空集合，但是不同于Collections.singleton()（可以在參考部分察看），他不帶任何參數，但需要指明返回類型。通過在方法名前的<>中，可以顯示的指明參數類型：

Set<String> empty = Collections.<String>emptySet();

　　類型參數不能同沒有限制的方法名結合使用：他們必須跟隨在一個.后或者在關鍵字new后，或者在關鍵字this前，或者構造函數的super前。
可以證明，如果如果你將Collections.emptySet()的返回值賦給一個變量，就像我們上邊通過類型推斷機制推斷基于變量類型的參數類型。盡管顯示的類型說明可以更加清楚，但這不是必要的，可以像下面一樣重寫：

Set<String> empty = Collections.emptySet();

　　在方法調用表達式中，顯示的說明emptySet()的返回值類型是必要的。比如，假設你要調用一個名為printWords()的方法，該方法僅需一個Set<String>的參數，如果你想傳遞一個空的集合給該方法，就要像下面一樣寫：

printWords(Collections.<String>emptySet());

這種情況下，顯示的類型說明是必要的。

范型方法和數組
早先我們看到，編譯器不允許創(chuàng)建一個類型參數化的數組。但是對于范型的使用會是不同的?？紤]一下前面定義的Util.fill()，它得以第一個參數和返回值類型都是T[]。而方法體內不必創(chuàng)建任何參數為T的數組，所以這個方法是合法的。

如果你創(chuàng)建一個方法使用varargs（參見第二章的2.6.4）和類型變量，記住調用varargs隱含創(chuàng)建一個數組，請看下面的例子：

/** Return the largest of the specified values or null if there are none */
public static <T extends Comparable<T>> T max(T... values) { ...  }

你可以使用一個Integer類型來調用這個方法，因為編譯器會在調用的時候插入必要的數組創(chuàng)建代碼。但是你不能將參數轉換為Comparable<Integer>來調用這個方法，因為創(chuàng)建一個Comparable<Integer>[]是不合法的。

參數化異常
異常是在運行時拋出和捕獲的。沒有辦法讓編譯器完成類型檢查，來保證在catch塊中拋出的未知的類型匹配異常。由于這個原因，catch塊很可能不包含類型變量和通配符。既然不可能保證在運行時捕獲一個編譯器時類型參數完整性異常，所以不允許創(chuàng)建任何Throwable類型的子類。參數化異常是不允許的。
但是你可以使用類型變量在throw塊里的方法簽名中?？纯聪旅娴睦樱?br/>

public interface Command<X extends Exception> {
    public void doit(String arg) throws X;
}

這個接口描述了一個“command”：一塊代碼只有一個String類型的參數，沒有返回值。代碼可能拋出一個類型為X的異常。這里有一個例子使用這個接口：

Command<IOException> save = new Command<IOException>() {
    public void doit(String filename) throws IOException {
        PrintWriter out = new PrintWriter(new FileWriter(filename));
        out.println("hello world");
        out.close();
    }
};

try { save.doit("/tmp/foo");  }
catch(IOException e) { System.out.println(e); }

范型個案研究：比較和枚舉
Java1.5引入的范型新特性，在1.5的API中有使用，特別多的是在java.util包中，但是在java.lang，java.lang.reflect和java.util.concurrent中也有。這些API都是經過仔細的斟酌創(chuàng)建的，通過學習這些API我們可以學到很多好的設計方法。

java.util中的范形是比較簡單的：因為大多都是集合類，類型變量也是代表集合中的元素。java.lang中的幾個重要范型是比較難以理解的，他們不是集合，而且第一眼很不容易理解為什么設計成范型。學習這些范型可以讓我們更深層次的理解范形的工作機制，并且介紹一些我們沒有提到的概念。特別的，我們要檢查Comparable接口和Enum類（枚舉類型的超類，后面一張講解）并且學習一些重要但是很少使用的范型特性，比如通配符下界。

在java1.5中，Comparable接口被修改為范型的。大多數的類都實現了這個接口，考慮一下Integer：

public final class Integer extends Number implements Comparable<Integer>

原先的Comparable接口在類型安全方面是有問題的。兩個繼承了Comparable接口的對象可能不能相互比較。JDK5.0前，非范形的Comparable接口是非常有用但是不安全的，而現在的接口，捕獲了我們需要的信息：他告訴我們一個對象是可比較的，并且可以同什么比較。

現在，考慮一下comparable類的子類。Integer是final的，所以不能有子類，那么讓我們看看java.math.BigInteger：

public class BigInteger extends Number implements Comparable<BigInteger>

如果我們實現一個BiggerInteger類是BigInteger的子類，他從父類那里繼承了Comparable接口，但是注意繼承的是Comparable<Integer>而不是Comparable<BiggerInteger>。這意味著BigInteger和BiggerInteger是可以相互比較的，這是非常好的。BiggerInteger可以重載compareTo()，但是不允許實現一個不同的參數化的Comparable。這就是說BiggerInteger不能同時繼承BigInteger和實現Comparable<BiggerInteger>。

當你使用可比較的對象時（當寫排序算法的時候）記住兩點。首先，使用原生類型是不夠充分的：考慮到類型安全，必須指明同什么比較。接下來，類型是不允許同自己比較的：有時候他會同他的祖先比較。為了具體說明，考慮java.util.Collections.max()：

這是一個冗長而且復雜的方法標簽，我們來一步步考慮：
方法中包含一個類型變量T，并且有復雜的綁定，稍后我們返回來討論。
方法的返回值類型是T。
方法名是max()。

方法的參數是一個集合。元素的類型指定為綁定的通配符。我們并不知道元素的確切類型，但直到有一個上限T。所以我們知道元素的類型要么為T，要么是T的子類。集合的任何元素都可以作為返回值使用。

這些是比較簡單的，本章我們已經看到了通配符上界，我們再來看看max()中的類型變量聲明：

<T extends Comparable<? super T>>

要說明的第一點，T必須實現了Comparable接口。（范型的語法使用關鍵字extends來代表類型綁定，不論是類或接口）這是期望的，因為這個方法是找到集合中最大的元素。但是觀察這個參數化的Comparable接口，這是一個通配符，但是這個通過關鍵字super來綁定，而不是extends。這是下界綁定。? extends T是我們熟悉的上界綁定：這意味著T或者其子類。? super T比較少用：這意味著T或者他的超類。

總結一下，類型變量聲明表明：“T是一個實現了Comparable接口或者他的父類實現了該接口的類型。”Collections.min()和Collections.binarySearch()有著相同的聲明。
對其他的下界通配符（對于Comparable接口沒有作用）的例子，Collections中的addAll()，copy()，和fill()。觀察addAll()的聲明：

public static <T> boolean addAll(Collection<? super T> c, T... a)

這是一個varargs方法，接受任意數量的參數，并且傳遞給他們一個T[]，命名為a。他將a中的所有元素都賦給集合c。集合的元素類型雖然不知道，但是有一個下界：元素均為T或者T的超類。不論類型是什么，我們可以確定數組的元素都是類型的實例，所以將數組的元素添加到集合中是合法的。

返回到我們先前討論的上界通配符，如果有一個集合的元素是上界通配符，那么都是只讀的。考慮List<? extends Serializable>。我們知道，所有的元素都是Serializable，所以像get()這樣的方法返回一個Serializable類型的返回值。編譯器不允許我們調用add()這樣的方法，因為實際的元素類型是不可知的。不能夠添加絕對的Serializable對象到list中，因為實現他們的類可能不是正確的類型。

既然上界統(tǒng)配符的結果是只讀的，所以你可能會期望下界通配符來實現只寫的集合。實際并不是這樣，假設這里有一個List<? extends Integer>。元素的實際類型是不知道的，但是可能性是Integer或者他的祖先類Number和Object。無論實際類型是什么，將Integer類型（而不是Number和Object對象）的元素添加到list中是安全的。無論實際類型是什么，list中所有元素都是Object對象的實例，所以list中像get()一樣的方法返回Object。

最后，讓我們把注意力放到java.lang.Enum類。Enum是所有枚舉類型的父類，它實現了Comparable接口，但是有一個讓人迷惑的范型聲明方法：

public class Enum<E extends Enum<E>> implements Comparable<E>, Serializable

第一眼，類型變量E的聲明在一個循環(huán)中。再仔細的看一看：聲明真正說明了，Enum必須是一個本身就是Enum類型的類型。這種表面上的循環(huán)是很顯然的，如果我們看到了implements子句。正如我們看到的，Comparable類通常被定義為可以同自己比較的。而且他們的子類也可以同他們的父類比較。從另一個方面將，Enum實現了Comparable接口不是為了他本身，而是為了他的子類E。