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

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

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

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

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

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

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); }
}

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

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

類型變量綁定
上面例子中的Tree<V>中的類型變量V是不受約束的：Tree可以被參數(shù)化為任何類型。以前我們常常會設置一些約束條件在需要使用的類型上：也許我們需要強制一個類型參數(shù)實現(xiàn)一個或多個接口，或是一個特定類的子類。這可以通過指明類型綁定來完成。我們已經(jīng)看到了統(tǒng)配符的上界，而且使用簡單的語法可以指定一般類型變量的上界。后面的代碼，還是使用Tree這個例子，并且通過實現(xiàn)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后的名字和一個類型列表（這可以是參數(shù)化的，就像Comparable一樣）表達的。注意當有不止一個綁定時，就像上面例子中的，綁定的類型要用&作為分隔符，而不是使用逗號。都后用來分隔類型變量，如果用來分隔類型變量綁定，就會模棱兩可。一個類型變量可以有任何數(shù)量的綁定，包括任何數(shù)量的借口和至多一個類。

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

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));

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

范型方法
　　正如前面說的，范型只能被實例成員調(diào)用，而不是靜態(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()不比通配符版本的簡單，而且聲明變量并沒有讓我們獲得什么。這種情況下，通配符方案要比范型方法更有效，當一個類型變量用來表達兩個參數(shù)之間或者參數(shù)和返回值之間的關(guān)系時，范型方法才是需要的。請看下面的例子：

// 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來約束參數(shù)和返回值有相同類型，并且參數(shù)是Number或者他的子類。

　　使得參數(shù)具有相同類型也許是有爭議的，應該讓我們能調(diào)用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沒有任何聯(lián)系，而且每個僅在簽名的時候使用，他們沒有提供比通配符更多的好處，這種方法最好這樣寫：

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

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

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

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

當你調(diào)用這個方法時，不需要指明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);

編譯器判斷范型方法的參數(shù)類型稱為類型推斷。類型推斷是相對于知覺推斷的。而實際編譯器的實現(xiàn)方法是一種非常復雜的過程，超過了這本書的討論范圍。更多的細節(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;
    }
}

這里有兩個該方法的調(diào)用：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

這個接口描述了一個“command”：一塊代碼只有一個String類型的參數(shù)，沒有返回值。代碼可能拋出一個類型為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都是經(jīng)過仔細的斟酌創(chuàng)建的，通過學習這些API我們可以學到很多好的設計方法。

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

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

public final class Integer extends Number implements Comparable<Integer>

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

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

public class BigInteger extends Number implements Comparable<BigInteger>

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

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

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

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

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

<T extends Comparable<? super T>>

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

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

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

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

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

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

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

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

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