Java程式員從笨鳥到菜鳥之（十）枚舉，泛型詳解

​

​

一：首先從枚舉開始說起

枚舉類型是JDK5.0的新特征。Sun引進了一個全新的關鍵字enum來定義一個枚舉類。下面就是一個典型枚舉類型的定義：

public enum Color{
 RED，BLUE，BLACK，YELLOW，GREEN
 }      

　 　顯然，enum很像特殊的class，實際上enum聲明定義的類型就是一個類。 而這些類都是類庫中Enum類的子類（java.lang.Enum）。它們繼承了這個Enum中的許多有用的方法。我們對代碼編譯之後發現，編譯器将 enum類型單獨編譯成了一個位元組碼檔案：Color.class。

Color位元組碼代碼

final enum hr.test.Color {
 // 所有的枚舉值都是類靜态常量
 public static final enum hr.test.Color RED;
 public static final enum hr.test.Color BLUE;
 public static final enum hr.test.Color BLACK;
 public static final enum hr.test.Color YELLOW;
 public static final enum hr.test.Color GREEN;
 private static final synthetic hr.test.Color［］ ENUM$VALUES;}      

下面我們就詳細介紹enum定義的枚舉類的特征及其用法。（後面均用Color舉例）

1、Color枚舉類就是class，而且是一個不可以被繼承的final類。其枚舉值（RED，BLUE.。.）都是Color類型的類靜态常量， 我們可以通過下面的方式來得到Color枚舉類的一個執行個體：

Color c=Color.RED;

注意：這些枚舉值都是public static final的，也就是我們經常所定義的常量方式，是以枚舉類中的枚舉值最好全部大寫。

2、即然枚舉類是class，當然在枚舉類型中有構造器，方法和資料域。但是，枚舉類的構造器有很大的不同：

（1） 構造器隻是在構造枚舉值的時候被調用。

Java代碼

enum Color{
 RED（255，0，0），BLUE（0，0，255），BLACK（0，0，0），YELLOW（255，255，0），GREEN（0，255，0）;
 //構造枚舉值，比如RED（255，0，0）
 private Color（int rv，int gv，int bv）{
 this.redValue=rv;
 this.greenValue=gv;
 this.blueValue=bv;
 }
 public String toString（）{ //覆寫了父類Enum的toString（）
 return super.toString（）+“（”+redValue+“，”+greenValue+“，”+blueValue+“）”;
 }
 private int redValue; //自定義資料域，private為了封裝。
 private int greenValue;
 private int blueValue;
 }      

　（2） 構造器隻能私有private，絕對不允許有public構造器。 這樣可以保證外部代碼無法新構造枚舉類的執行個體。這也是完全符合情理的，因為我們知道枚舉值是public static final的常量而已。 但枚舉類的方法和資料域可以允許外部通路。

Java代碼

public static void main（String args［］）
 {
 // Color colors=new Color（100，200，300）; //wrong
 Color color=Color.RED;
 System.out.println（color）; // 調用了toString（）方法
 }      

3、所有枚舉類都繼承了Enum的方法，下面我們詳細介紹這些方法。

（1） ordinal（）方法： 傳回枚舉值在枚舉類種的順序。這個順序根據枚舉值聲明的順序而定。

Color.RED.ordinal（）; //傳回結果：0
 Color.BLUE.ordinal（）; //傳回結果：1
 （2） compareTo（）方法： Enum實作了java.lang.Comparable接口，是以可以比較象與指定對象的順序。Enum中的compareTo傳回的是兩個枚舉值的順 序之差。當然，前提是兩個枚舉值必須屬于同一個枚舉類，否則會抛出ClassCastException（）異常。（具體可見源代碼）
 Color.RED.compareTo（Color.BLUE）; //傳回結果 -1
 （3） values（）方法： 靜态方法，傳回一個包含全部枚舉值的數組。
 Color［］ colors=Color.values（）;
 for（Color c:colors）{
 System.out.print（c+“，”）;
 }//傳回結果：RED，BLUE，BLACK YELLOW，GREEN，
 （4） toString（）方法： 傳回枚舉常量的名稱。
 Color c=Color.RED;
 System.out.println（c）;//傳回結果： RED
 （5） valueOf（）方法： 這個方法和toString方法是相對應的，傳回帶指定名稱的指定枚舉類型的枚舉常量。
 Color.valueOf（“BLUE”）; //傳回結果： Color.BLUE
 （6） equals（）方法： 比較兩個枚舉類對象的引用。
 Java代碼
 //JDK源代碼：
 public final boolean equals（Object other） {
 return this==other;
 }
 4、枚舉類可以在switch語句中使用。
 Java代碼
 Color color=Color.RED;
 switch（color）{
 case RED： System.out.println（“it‘s red”）;break;
 case BLUE： System.out.println（“it’s blue”）;break;
 case BLACK： System.out.println（“it‘s blue”）;break;
 }      

二：然後看泛型

泛型（Generic type 或者generics）是對 Java 語言的類型系統的一種擴充，以支援建立可以按類型進行參數化的類。可以把類型參數看作是使用參數化類型時指定的類型的一個占位符，就像方法的形式參數是運作時傳遞的值的占位符一樣。

1.泛型的好處：

1）類型安全。泛型的主要目标是提高 Java 程式的類型安全。通過知道使用泛型定義的變量的類型限制，編譯器可以在一個高得多的程度上驗證類型假設。沒有泛型，這些假設就隻存在于程式員的頭腦中（或者如果幸運的話，還存在于代碼注釋中）。

2）·消除強制類型轉換。泛型的一個附帶好處是，消除源代碼中的許多強制類型轉換。這使得代碼更加可讀，并且減少了出錯機會。 盡管減少強制類型轉換可以降低使用泛型類的代碼的羅嗦程度，但是聲明泛型變量會帶來相應的羅嗦

3）· 潛在的性能收益。泛型為較大的優化帶來可能。在泛型的初始實作中，編譯器将強制類型轉換（沒有泛型的話，程式員會指定這些強制類型轉換）插入生成的位元組碼中。但是更多類型資訊可用于編譯器這一事實，為未來版本的JVM 的優化帶來可能。

2.類型參數：

在定義泛型類或聲明泛型類的變量時，使用尖括号來指定形式類型參數。形式類型參數與實際類型參數之間的關系類似于形式方法參數與實際方法參數之間的關系，隻是類型參數表示類型，而不是表示值。

泛型類中的類型參數幾乎可以用于任何可以使用類名的地方。例如，下面是java.util.Map接口的定義的摘錄：

public interface Map<K, V> { 
 public void put(K key, V value); 
 public V get(K key); 
 }      

3.泛型不是協變的

關于泛型的混淆，一個常見的來源就是假設它們像數組一樣是協變的。其實它們不是協變的。List<Object>不是List<String>的父類型。

如果 A 擴充 B，那麼 A 的數組也是 B 的數組，并且完全可以在需要B[]的地方使用A[]：

Integer[] intArray = new Integer[10]; 
 Number[] numberArray = intArray;      

上面的代碼是有效的，因為一個Integer是一個Number，因而一個Integer數組是一個Number數組。但是對于泛型來說則不然。下面的代碼是無效的

List<Integer> intList = new ArrayList<Integer>(); 
 List<Number> numberList = intList; // invalid      

4.泛型中的類型通配符

假設您具有該方法：

void printList(List l) { 
 for (Object o : l) 
 System.out.println(o); 
 }      

上面的代碼在 JDK 5.0 上編譯通過，但是如果試圖用List<Integer>調用它，則會得到警告。出現警告是因為，您将泛型 （List<Integer>）傳遞給一個隻承諾将它當作List（所謂的原始類型）的方法，這将破壞使用泛型的類型安全。

如果試圖編寫像下面這樣的方法，那麼将會怎麼樣？

void printList(List<Object> l) { 
 for (Object o : l) 
 System.out.println(o); 
 }      

它仍然不會通過編譯，因為一個List<Integer>不是一個List<Object>（正如前一屏泛型不是協變的 中所學的）。這才真正煩人——現在您的泛型版本還沒有普通的非泛型版本有用！ 解決方案是使用類型通配符：

void printList(List<?> l) { 
 for (Object o : l) 
 System.out.println(o); 
 }      

上面代碼中的問号是一個類型通配符。它讀作“問号”。List<?>是任何泛型List的父類型，是以您完全可以将 List<Object>、List<Integer>或 List<List<List<Flutzpah>>>傳遞給printList()。

5.泛型方法

（在類型參數 一節中）您已經看到，通過在類的定義中添加一個形式類型參數清單，可以将類泛型化。方法也可以被泛型化，不管它們定義在其中的類是不是泛型化的。

泛型類在多個方法簽名間實施類型限制。在List<V>中，類型參數V出現在get()、add()、contains()等方法的簽名中。 當建立一個Map<K, V>類型的變量時，您就在方法之間宣稱一個類型限制。您傳遞給add()的值将與get()傳回的值的類型相同。

類似地，之是以聲明泛型方法，一般是因為您想要在該方法的多個參數之間宣稱一個類型限制。例如，下面代碼中的ifThenElse()方法，根據它的第一個參數的布爾值，它将傳回第二個或第三個參數：

public <T> T ifThenElse(boolean b, T first, T second) { 
 return b ? first : second; 
 }