泰仔在線

泛型類型，第一部分
作者: David Flanagan
翻譯：cat

版權(quán)聲明：可以任意轉(zhuǎn)載，轉(zhuǎn)載時請務(wù)必以超鏈接形式標(biāo)明文章原始出處和作者信息及本聲明
作者:
David Flanagan;cat
原文地址:
http://www.onjava.com/pub/a/onjava/excerpt/javaian5_chap04/index.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43864_Generic_Types.html
關(guān)鍵詞： Generic Types


編輯按：《Java in a Nutshell, 5th Edition》覆蓋了jdk5.0中很多變化和新特征，其中最重要的就是泛型。在本文的第一部分，作者David Flanagan介紹了如何使用泛型；而在第二部分，作者描述了如何寫你自己的泛型和泛型方法。

Java5.0的新特性之一是引入了泛型類型和泛型方法。一個泛型類型通過使用一個或多個類型變量來定義，并擁有一個或多個使用一個類型變量作為一個參數(shù)或者返回值的占位符。例如，類型java.util.List<E>是一個泛型類型：一個list，其元素的類型被占位符E描述。這個類型有一個名為add()的方法，被聲明為有一個類型為E的參數(shù)，同時，有一個get()方法，返回值被聲明為E類型。

為了使用泛型類型，你應(yīng)該為類型變量詳細(xì)指明實(shí)際的類型，形成一個就像List<String>類似的參數(shù)化類型。[1]指明這些額外的類型信息的原因是編譯器據(jù)此能夠在編譯期為您提供很強(qiáng)的類型檢查，增強(qiáng)您的程序的類型安全性。舉個例子來說，您有一個只能保持String對象的List，那么這種類型檢查就能夠阻止您往里面加入String[]對象。同樣的，增加的類型信息使編譯器能夠?yàn)槟鲆恍╊愋娃D(zhuǎn)換的事情。比如，編譯器知道了一個List<String>有個get()方法，其返回值是一個String對象，因此您不再需要去將返回值由一個Object強(qiáng)制轉(zhuǎn)換為String。

Java.util包中的集合類在java5.0中已經(jīng)被做成了泛型，也許您將會在您的程序中頻繁的使用到他們。類型安全的集合類就是一個泛型類型的典型案例。即便您從沒有定義過您自己的泛型類型甚至從未用過除了java.util中的集合類以外的泛型類型，類型安全的集合類的好處也是極有意義的一個標(biāo)志——他們證明了這個主要的新語言特性的復(fù)雜性。

我們從探索類型安全的集合類中的基本的泛型用法開始，進(jìn)而研究更多使用泛型類型的復(fù)雜細(xì)節(jié)。然后我們討論類型參數(shù)通配符和有界通配符。描繪了如何使用泛型以后，我們闡明如何編寫自己的泛型類型和泛型方法。我們對于泛型的討論將結(jié)束于一趟對于JavaAPI的核心中重要的泛型類型的旅行。這趟旅程將探索這些類型以及他們的用法，旅程的目的是為了讓您對泛型如何工作這個問題有個深入的理解。

類型安全集合類

Java.util類包包含了Java集合框架（Java Collections Framework），這是一批包含對象的set、對象的list以及基于key-value的map。第五章將談到集合類。這里，我們討論的是在java5.0中集合類使用類型參數(shù)來界定集合中的對象的類型。這個討論并不適合java1.4或更早期版本。如果沒有泛型，對于集合類的使用需要程序員記住每個集合中元素的類型。當(dāng)您在java1.4種創(chuàng)建了一個集合，您知道您放入到集合中的對象的類型，但是編譯器不知道。您必須小心地往其中加入一個合適類型的元素，當(dāng)需要從集合中獲取元素時，您必須顯式的寫強(qiáng)制類型轉(zhuǎn)換以將他們從Object轉(zhuǎn)換為他們真是的類型。考察下邊的java1.4的代碼。

public static void main(String[] args) {
    // This list is intended to hold only strings.
    // The compiler doesn't know that so we have to remember ourselves.
    List wordlist = new ArrayList();  

    // Oops! We added a String[] instead of a String.
    // The compiler doesn't know that this is an error.
    wordlist.add(args);

    // Since List can hold arbitrary objects, the get() method returns
    // Object.  Since the list is intended to hold strings, we cast the
    // return value to String but get a ClassCastException because of
    // the error above.
    String word = (String)wordlist.get(0);
}

泛型類型解決了這段代碼中的顯示的類型安全問題。Java.util中的List或是其他集合類已經(jīng)使用泛型重寫過了。就像前面提到的， List被重新定義為一個list，它中間的元素類型被一個類型可變的名稱為E的占位符描述。Add()方法被重新定義為期望一個類型為E的參數(shù)，用于替換以前的Object，get()方法被重新定義為返回一個E，替換了以前的Object。

在java5.0中，當(dāng)我們申明一個List或者創(chuàng)建一個ArrayList的實(shí)例的時候，我們需要在泛型類型的名字后面緊跟一對“<>”，尖括號中寫入我們需要的實(shí)際的類型。比如，一個保持String的List應(yīng)該寫成“List<String>”。需要注意的是，這非常象給一個方法傳一個參數(shù)，區(qū)別是我們使用類型而不是值，同時使用尖括號而不是圓括號

Java.util的集合類中的元素必須是對象化的，他們不能是基本類型。泛型的引入并沒有改變這點(diǎn)。泛型不能使用基本類型：我們不能這樣來申明——Set<char>或者List<int>。記住，無論如何，java5.0中的自動打包和自動解包特性使得使用Set<Character>或者List<Integer>和直接使用char和int值一樣方便。（查看第二章以了解更多關(guān)于自動打包和自動解包的細(xì)節(jié)）。

在Java5.0中，上面的例子將被重寫為如下方式：

public static void main(String[] args) {
    // This list can only hold String objects
    List<String> wordlist = new ArrayList<String>();

    // args is a String[], not String, so the compiler won't let us do this
    wordlist.add(args);  // Compilation error!

    // We can do this, though.  
    // Notice the use of the new for/in looping statement
    for(String arg : args) wordlist.add(arg);

    // No cast is required.  List<String>.get() returns a String.
    String word = wordlist.get(0);
}

值得注意的是代碼量其實(shí)并沒有比原來那個沒有泛型的例子少多少。使用“(String)”這樣的類型轉(zhuǎn)換被替換成了類型參數(shù)“<String>”。 不同的是類型參數(shù)需要且僅需要聲明一次，而list能夠被使用任何多次，不需要類型轉(zhuǎn)換。在更長點(diǎn)的例子代碼中，這一點(diǎn)將更加明顯。即使在那些看上去泛型語法比非泛型語法要冗長的例子里，使用泛型依然是非常有價值的——額外的類型信息允許編譯器在您的代碼里執(zhí)行更強(qiáng)的錯誤檢查。以前只能在運(yùn)行起才能發(fā)現(xiàn)的錯誤現(xiàn)在能夠在編譯時就被發(fā)現(xiàn)。此外，以前為了處理類型轉(zhuǎn)換的異常，我們需要添加額外的代碼行。如果沒有泛型，那么當(dāng)發(fā)生類型轉(zhuǎn)換異常的時候，一個ClassCastException異常就會被從實(shí)際代碼中拋出。

就像一個方法可以使用任意數(shù)量的參數(shù)一樣，類允許使用多個類型變量。接口Java.util.Map就是一個例子。一個Map體現(xiàn)了從一個key的對象到一個value的對象的映射關(guān)系。接口Map申明了一個類型變量來描述key的類型而另一個類型變量來描述value的類型。舉個例子來說，假設(shè)您希望做一個String對象到Integer對象的映射關(guān)系：

public static void main(String[] args) {
    // A map from strings to their position in the args[] array
    Map<String,Integer> map = new HashMap<String,Integer>();

    // Note that we use autoboxing to wrap i in an Integer object.
    for(int i=0; i < args.length; i++) map.put(args[i], i);  

    // Find the array index of a word.  Note no cast is required!
    Integer position = map.get("hello");

    // We can also rely on autounboxing to convert directly to an int,
    // but this throws a NullPointerException if the key does not exist 
    // in the map
    int pos = map.get("world");
}

象List<String>這個一個參數(shù)類型其本身也是也一個類型，也能夠被用于當(dāng)作其他類型的一個類型變量值。您可能會看到這樣的代碼：

// Look at all those nested angle brackets!
Map<String, List<List<int[]>>> map = getWeirdMap();

// The compiler knows all the types and we can write expressions
// like this without casting.  We might still get NullPointerException
// or ArrayIndexOutOfBounds at runtime, of course.
int value = map.get(key).get(0).get(0)[0];

// Here's how we break that expression down step by step.
List<List<int[]>> listOfLists = map.get(key);
List<int[]> listOfIntArrays = listOfLists.get(0);
int[] array = listOfIntArrays.get(0);
int element = array[0];

在上面的代碼里，java.util.List<E>和java.util.Map<K,V>的get()方法返回一個類型為E的list元素或者一個類型為V的map元素。注意，無論如何，泛型類型能夠更精密的使用他們的變量。在本書中的參考章節(jié)查看List<E>，您將會看到它的iterator( )方法被聲明為返回一個Iterator<E>。這意味著，這個方法返回一個跟list的實(shí)際的參數(shù)類型一樣的一個參數(shù)類型的實(shí)例。為了具體的說明這點(diǎn)，下面的例子提供了不使用get(0)方法來獲取一個List<String>的第一個元素的方法。

List<String> words = // ...initialized elsewhere...
Iterator<String> iterator = words.iterator();
String firstword = iterator.next();

理解泛型類型

本段將對泛型類型的使用細(xì)節(jié)做進(jìn)一步的探討，以嘗試說明下列問題：
不帶類型參數(shù)的使用泛型的后果
參數(shù)化類型的體系
一個關(guān)于編譯期泛型類型的類型安全的漏洞和一個用于確保運(yùn)行期類型安全的補(bǔ)丁
為什么參數(shù)化類型的數(shù)組不是類型安全的

未經(jīng)處理的類型和不被檢查的警告
即使被重寫的Java集合類帶來了泛型的好處，在使用他們的時候您也不被要求說明類型變量。一個不帶類型變量的泛型類型被認(rèn)為是一個未經(jīng)處理的類型（raw type）。這樣，5.0版本以前的java代碼仍然能夠運(yùn)行：您顯式的編寫所有類型轉(zhuǎn)換就像您已經(jīng)這樣寫的一樣，您可能會被一些來自編譯器的麻煩所困擾。查看下列存儲不同類型的對象到一個未經(jīng)處理的List：

List l = new ArrayList();
l.add("hello");  
l.add(new Integer(123));
Object o = l.get(0);

這段代碼在java1.4下運(yùn)行得很好。如果您用java5.0來編譯它，javac編譯了，但是會打印出這樣的“抱怨”：

Note: Test.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

如果我們加入-Xlint參數(shù)后重新編譯，我們會看到這些警告：

Test.java:6: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add("hello");  
         ^
Test.java:7: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add(new Integer(123));
         ^
編譯在add()方法的調(diào)用上給出了警告，因?yàn)樗荒軌虼_信加入到list中的值具有正確的類型。它告訴我們說我們使用了一個未經(jīng)處理的類型，它不能驗(yàn)證我們的代碼是類型安全的。注意，get()方法的調(diào)用是沒有問題的，因?yàn)槟軌虮猾@得的元素已經(jīng)安全的存在于list中了。

如果您不想使用任何的java5.0的新特性，您可以簡單的通過帶-source1.4標(biāo)記來編譯他們，這樣編譯器就不會再“抱怨”了。如果您不能這樣做，您可以忽略這些警告，通過使用一個“@SuppressWarnings("unchecked")”注解（查看本章的4.3節(jié)）隱瞞這些警告信息或者升級您的代碼，加入類型變量描述。[2]下列示例代碼，編譯的時候不再會有警告但仍然允許您往list中放入不同的類型的對象。

List<Object> l = new ArrayList<Object>();
l.add("hello");  
l.add(123);              // autoboxing
Object o = l.get(0);

參數(shù)化類型的體系

參數(shù)化類型有類型體系，就像一般的類型一樣。這個體系基于對象的類型，而不是變量的類型。這里有些例子您可以嘗試：

ArrayList<Integer> l = new ArrayList<Integer>();
List<Integer> m = l;                            // okay
Collection<Integer> n = l;                      // okay
ArrayList<Number> o = l;                        // error
Collection<Object> p = (Collection<Object>)l;   // error, even with cast

一個List<Integer>是一個Collection<Integer>，但不是一個List<Object>。這句話不容易理解，如果您想理解為什么泛型這樣做，這段值得看一下。考察這段代碼：

List<Integer> li = new ArrayList<Integer>();
li.add(123);

// The line below will not compile.  But for the purposes of this
// thought-experiment, assume that it does compile and see how much
// trouble we get ourselves into.
List<Object> lo = li;  

// Now we can retrieve elements of the list as Object instead of Integer
Object number = lo.get(0);

// But what about this?
lo.add("hello world");

// If the line above is allowed then the line below throws ClassCastException
Integer i = li.get(1);  // Can't cast a String to Integer!

這就是為什么List<Integer>不是一個List<Object>的原因，雖然List<Integer>中所有的元素事實(shí)上是一個Object的實(shí)例。如果允許轉(zhuǎn)換成List<Object>，那么轉(zhuǎn)換后，理論上非整型的對象也將被允許添加到list中。

運(yùn)行時類型安全

就像我們所見到的，一個List<X>不允許被轉(zhuǎn)換為一個List<Y>，即使這個X能夠被轉(zhuǎn)換為Y。然而，一個List<X>能夠被轉(zhuǎn)換為一個List，這樣您就可以通過繼承的方法來做這樣的事情。
這種將參數(shù)化類型轉(zhuǎn)換為非參數(shù)化類型的能力對于向下兼容是必要的，但是它會在泛型所帶來的類型安全體系上鑿個漏洞：

// Here's a basic parameterized list.
List<Integer> li = new ArrayList<Integer>();

// It is legal to assign a parameterized type to a nonparameterized variable
List l = li;   

// This line is a bug, but it compiles and runs.
// The Java 5.0 compiler will issue an unchecked warning about it.
// If it appeared as part of a legacy class compiled with Java 1.4, however,
// then we'd never even get the warning.  
l.add("hello");

// This line compiles without warning but throws ClassCastException at runtime.
// Note that the failure can occur far away from the actual bug.
Integer i = li.get(0);

泛型僅提供了編譯期的類型安全。如果您使用java5.0的編譯器來編譯您的代碼并且沒有得到任何警告，這些編譯器的檢查能夠確保您的代碼在運(yùn)行期也是類型安全的。如果您獲得了警告或者使用了像未經(jīng)處理的類型那樣修改您的集合的代碼，那么您需要增加一些步驟來確保運(yùn)行期的類型安全。您可以通過使用java.util.Collections中的checkedList()和checkedMap( )方法來做到這一步。這些方法將把您的集合打包成一個wrapper集合，從而在運(yùn)行時檢查確認(rèn)只有正確類型的值能夠被置入集合眾。下面是一個能夠補(bǔ)上類型安全漏洞的一個例子：

// Here's a basic parameterized list.
List<Integer> li = new ArrayList<Integer>();

// Wrap it for runtime type safety
List<Integer> cli = Collections.checkedList(li, Integer.class);

// Now widen the checked list to the raw type
List l = cli;   

// This line compiles but fails at runtime with a ClassCastException.
// The exception occurs exactly where the bug is, rather than far away
l.add("hello");

參數(shù)化類型的數(shù)組

在使用泛型類型的時候，數(shù)組需要特別的考慮。回憶一下，如果T是S的父類（或者接口），那么類型為S的數(shù)組S[]，同時又是類型為T的數(shù)組T[]。正因?yàn)槿绱耍看文娣乓粋€對象到數(shù)組中時，Java解釋器都必須進(jìn)行檢查以確保您放入的對象類型與要存放的數(shù)組所允許的類型是匹對的。例如，下列代碼在運(yùn)行期會檢查失敗，拋出一個ArrayStoreException異常：

String[] words = new String[10];
Object[] objs = words;
objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

雖然編譯時obj是一個Object[]，但是在運(yùn)行時它是一個String[]，它不允許被用于存放一個Integer.
當(dāng)我們使用泛型類型的時候，僅僅依靠運(yùn)行時的數(shù)組存放異常檢查是不夠的，因?yàn)橐粋€運(yùn)行時進(jìn)行的檢查并不能夠獲取編譯時的類型參數(shù)信息。查看下列代碼：

List<String>[] wordlists = new ArrayList<String>[10];
ArrayList<Integer> ali = new ArrayList<Integer>();
ali.add(123);
Object[] objs = wordlists;
objs[0] = ali;                       // No ArrayStoreException
String s = wordlists[0].get(0);      // ClassCastException!

如果上面的代碼被允許，那么運(yùn)行時的數(shù)組存儲檢查將會成功：沒有編譯時的類型參數(shù)，代碼簡單地存儲一個ArrayList到一個ArrayList[]數(shù)組，非常正確。既然編譯器不能阻止您通過這個方法來戰(zhàn)勝類型安全，那么它轉(zhuǎn)而阻止您創(chuàng)建一個參數(shù)化類型的數(shù)組。所以上述情節(jié)永遠(yuǎn)不會發(fā)生，編譯器在第一行就開始拒絕編譯了。

注意這并不是一個在使用數(shù)組時使用泛型的全部的約束，這僅僅是一個創(chuàng)建一個參數(shù)化類型數(shù)組的約束。我們將在學(xué)習(xí)如何寫泛型方法時再來討論這個話題。


類型參數(shù)通配符
假設(shè)我們需要寫一個方法來顯示一個List中的元素。[3]在以前，我們只需要象這樣寫段代碼：

public static void printList(PrintWriter out, List list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}

在Java5.0中，List是一個泛型類型，如果我們試圖編譯這個方法，我們將會得到unchecked警告。為了解決這些警告，您可能需要這樣來修改這個方法：

public static void printList(PrintWriter out, List<Object> list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}

這段代碼能夠編譯通過同時不會有警告，但是它并不是非常地有效，因?yàn)橹挥心切┍宦暶鳛長ist<Object>的list才會被允許使用這個方法。還記得么，類似于List<String>和List<Integer>這樣的List并不能被轉(zhuǎn)型為List<Object>。事實(shí)上我們需要一個類型安全的printList()方法，它能夠接受我們傳入的任何List，而不關(guān)心它被參數(shù)化為什么。解決辦法是使用類型參數(shù)通配符。方法可以被修改成這樣：

public static void printList(PrintWriter out, List<?> list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        Object o = list.get(i);
        out.print(o.toString());
    }
}

這個版本的方法能夠被編譯過，沒有警告，而且能夠在任何我們希望使用的地方使用。通配符“？”表示一個未知類型，類型List<?>被讀作“List of unknown”
作為一般原則，如果類型是泛型的，同時您并不知道或者并不關(guān)心值的類型，您應(yīng)該使用“?”通配符來代替一個未經(jīng)處理的類型。未經(jīng)處理的類型被允許僅是為了向下兼容，而且應(yīng)該只能夠被允許出現(xiàn)在老的代碼中。注意，無論如何，您不能在調(diào)用構(gòu)造器時使用通配符。下面的代碼是非法的：
List<?> l = new ArrayList<?>();

創(chuàng)建一個不知道類型的List是毫無道理的。如果您創(chuàng)建了它，那么您必須知道它將保持的元素是什么類型的。您可以在隨后的方法中不關(guān)心元素類型而去遍歷這里list，但是您需要在您創(chuàng)建它的時候描述元素的類型。如果你確實(shí)需要一個List來保持任何類型，那么您只能這么寫：

List<Object> l = new ArrayList<Object>();

從上面的printList()例子中，必須要搞清楚List<？>既不是List<Object>也不是一個未經(jīng)處理的List。一個使用通配符的List<?>有兩個重要的特性。第一，考察類似于get()的方法，他們被聲明返回一個值，這個值的類型是類型參數(shù)中指定的。在這個例子中，類型是“unknown”，所以這些方法返回一個Object。既然我們期望的是調(diào)用這個object的toString()方法，程序能夠很好的滿足我們的意愿。

第二，考察List的類似add()的方法，他們被聲明為接受一個參數(shù)，這個參數(shù)被類型參數(shù)所定義。出人意料的是，當(dāng)類型參數(shù)是未確定的，編譯器不允許您調(diào)用任何有不確定參數(shù)類型的方法——因?yàn)樗荒艽_認(rèn)您傳入了一個恰當(dāng)?shù)闹怠Ｒ粋€List(？)實(shí)際上是只讀的——既然編譯器不允許我們調(diào)用類似于add(),set(),addAll()這類的方法。

界定通配符
讓我們在我們原來的例子上作些小小的稍微復(fù)雜一點(diǎn)的改動。假設(shè)我們希望寫一個sumList()方法來計(jì)算list中Number類型的值的合計(jì)。在以前，我們使用未經(jīng)處理的List，但是我們不想放棄類型安全，同時不得不處理來自編譯器的unchecked警告。或者我們可以使用List<Number>，那樣的話我們就不能調(diào)用List<Integer>、List<Double>中的方法了，而事實(shí)上我們需要調(diào)用。如果我們使用通配符，那么我們實(shí)際上不能得到我們期望的類型安全，我們不能確定我們的方法被什么樣的List所調(diào)用，Number？還是Number的子類？甚至，String?這樣的一個方法也許會被寫成這樣：

public static double sumList(List<?> list) {
    double total = 0.0;
    for(Object o : list) {
        Number n = (Number) o;  // A cast is required and may fail
        total += n.doubleValue();
    }
    return total;
}

要修改這個方法讓它變得真正的類型安全，我們需要使用界定通配符（bounded wildcard），能夠確保List的類型參數(shù)是未知的，但又是Number或者Number的子類。下面的代碼才是我們想要的：

public static double sumList(List<? extends Number> list) {
    double total = 0.0;
    for(Number n : list) total += n.doubleValue();
    return total;
}

類型List<? extends Number>可以被理解為“Number未知子類的List”。理解這點(diǎn)非常重要，在這段文字中，Number被認(rèn)為是其自身的子類。

注意，這樣的話，那些類型轉(zhuǎn)換已經(jīng)不再需要了。我們并不知道list中元素的具體類型，但是我們知道他們能夠向上轉(zhuǎn)型為Number，因此我們可以把他們從list中把他們當(dāng)作一個Number對象取出。使用一個for/in循環(huán)能夠稍微封裝一下從list中取出元素的過程。普遍性的原則是當(dāng)您使用一個界定通配符時，類似于List中的get()方法的那些方法將返回一個類型為上界的值。因此如果我們在for/in循環(huán)中調(diào)用list.get()，我們將得到一個Number。在前一節(jié)說到使用通配符時類似于list.add()這種方法中的限制依然有效：舉個例子來說，如果編譯器允許我們調(diào)用這類方法，我們就可以將一個Integer放到一個聲明為僅保持Short值的list中去。

同樣可行的是使用下界通配符，不同的是用super替換extends。這個技巧在被調(diào)用的方法上有一點(diǎn)不同的作用。在實(shí)際應(yīng)用中，下界通配符要比上界通配符用得少。我們將在后面的章節(jié)里討論這個問題。


腳注
[1] 在本章中，我會堅(jiān)持用術(shù)語”泛型類型”來指一個聲明一個或多個類型變量的類型，用”參數(shù)化的類型”來指由實(shí)際類型參數(shù)來替換其類型變量的泛型類型。然而，在一般情況下，這種區(qū)別并不明顯，并且這些術(shù)語有時通用。
[2] 在撰寫本文時候，javac并不支持@SuppressWarnings 的注解。期望在Java 5.1中得到支持。
[3] 本節(jié)所示的3個printList()方法忽略了這樣一個事實(shí)，即java.util 中List的所有實(shí)現(xiàn)類都有一個可用的toString()方法。還要注意這些方法假定List實(shí)現(xiàn)RandomAccess并在LinkedList實(shí)例中只提供了很差的運(yùn)行效率。
David Flanagan是眾多O'Reilly書籍的作者。這些書包括《Java in a Nutshell》，《Java Examples in a Nutshell》，《Java Foundation Classes in a Nutshell》，《JavaScript: The Definitive Guide》，《JavaScript Pocket Reference》。

在Java in a Nutshell, 5th Edition中查看目錄信息。