詳解Java中的 枚舉與泛型

一：首先從枚舉開始說起

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

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

　 　顯然，enum很像特殊的class，實際上enum聲明定義的類型就是一個類。 而這些類都是類庫中Enum類的子類（Java.lang.Enum）。它們繼承了這個Enum中的許多有用的方法。我們對代碼編譯之后發(fā)現(xiàn)，編譯器將 enum類型單獨編譯成了一個字節(jié)碼文件：Color.class。

Color字節(jié)碼代碼

final enum hr.test.Color {
// 所有的枚舉值都是類靜態(tài)常量
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類型的類靜態(tài)常量， 我們可以通過下面的方式來得到Color枚舉類的一個實例：

Color c=Color.RED;

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

2、即然枚舉類是class，當(dāng)然在枚舉類型中有構(gòu)造器，方法和數(shù)據(jù)域。但是，枚舉類的構(gòu)造器有很大的不同：

（1） 構(gòu)造器只是在構(gòu)造枚舉值的時候被調(diào)用。

enum Color{
RED（255，0，0），BLUE（0，0，255），BLACK（0，0，0），YELLOW（255，255，0），GREEN（0，255，0）;
//構(gòu)造枚舉值，比如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; //自定義數(shù)據(jù)域，private為了封裝。
private int greenValue;
private int blueValue;
}

　?。?） 構(gòu)造器只能私有private，絕對不允許有public構(gòu)造器。 這樣可以保證外部代碼無法新構(gòu)造枚舉類的實例。這也是完全符合情理的，因為我們知道枚舉值是public static final的常量而已。 但枚舉類的方法和數(shù)據(jù)域可以允許外部訪問。

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

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

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

Color.RED.ordinal（）; //返回結(jié)果：0
Color.BLUE.ordinal（）; //返回結(jié)果：1

（2） compareTo（）方法： Enum實現(xiàn)了java.lang.Comparable接口，因此可以比較象與指定對象的順序。Enum中的compareTo返回的是兩個枚舉值的順 序之差。當(dāng)然，前提是兩個枚舉值必須屬于同一個枚舉類，否則會拋出ClassCastException（）異常。（具體可見源代碼）

Color.RED.compareTo（Color.BLUE）; //返回結(jié)果 -1

（3） values（）方法： 靜態(tài)方法，返回一個包含全部枚舉值的數(shù)組。

Color［］ colors=Color.values（）;
for（Color c:colors）{
System.out.print（c+“，”）;
}//返回結(jié)果：RED，BLUE，BLACK YELLOW，GREEN，

（4） toString（）方法： 返回枚舉常量的名稱。

Color c=Color.RED;
System.out.println（c）;//返回結(jié)果： RED

（5） valueOf（）方法： 這個方法和toString方法是相對應(yīng)的，返回帶指定名稱的指定枚舉類型的枚舉常量。

Color.valueOf（“BLUE”）; //返回結(jié)果： Color.BLUE

（6） equals（）方法： 比較兩個枚舉類對象的引用。

//JDK源代碼：
public final boolean equals（Object other） {
return this==other;
}

4、枚舉類可以在switch語句中使用。

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 語言的類型系統(tǒng)的一種擴展，以支持創(chuàng)建可以按類型進行參數(shù)化的類。可以把類型參數(shù)看作是使用參數(shù)化類型時指定的類型的一個占位符，就像方法的形式參數(shù)是運行時傳遞的值的占位符一樣。

1.泛型的好處：

1）類型安全。泛型的主要目標是提高 Java 程序的類型安全。通過知道使用泛型定義的變量的類型限制，編譯器可以在一個高得多的程度上驗證類型假設(shè)。沒有泛型，這些假設(shè)就只存在于程序員的頭腦中（或者如果幸運的話，還存在于代碼注釋中）。
2）·消除強制類型轉(zhuǎn)換。泛型的一個附帶好處是，消除源代碼中的許多強制類型轉(zhuǎn)換。這使得代碼更加可讀，并且減少了出錯機會。 盡管減少強制類型轉(zhuǎn)換可以降低使用泛型類的代碼的羅嗦程度，但是聲明泛型變量會帶來相應(yīng)的羅嗦
3）· 潛在的性能收益。泛型為較大的優(yōu)化帶來可能。在泛型的初始實現(xiàn)中，編譯器將強制類型轉(zhuǎn)換（沒有泛型的話，程序員會指定這些強制類型轉(zhuǎn)換）插入生成的字節(jié)碼中。但是更多類型信息可用于編譯器這一事實，為未來版本的JVM 的優(yōu)化帶來可能。

2.類型參數(shù)：

在定義泛型類或聲明泛型類的變量時，使用尖括號來指定形式類型參數(shù)。形式類型參數(shù)與實際類型參數(shù)之間的關(guān)系類似于形式方法參數(shù)與實際方法參數(shù)之間的關(guān)系，只是類型參數(shù)表示類型，而不是表示值。

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

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

3.泛型不是協(xié)變的

關(guān)于泛型的混淆，一個常見的來源就是假設(shè)它們像數(shù)組一樣是協(xié)變的。其實它們不是協(xié)變的。List<Object>不是List<String>的父類型。

如果 A 擴展 B，那么 A 的數(shù)組也是 B 的數(shù)組，并且完全可以在需要B[]的地方使用A[]：

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

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

下面的代碼是無效的

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

4.泛型中的類型通配符

假設(shè)您具有該方法：

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

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

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

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

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

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

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

5.泛型方法

（在類型參數(shù) 一節(jié)中）您已經(jīng)看到，通過在類的定義中添加一個形式類型參數(shù)列表，可以將類泛型化。方法也可以被泛型化，不管它們定義在其中的類是不是泛型化的。

泛型類在多個方法簽名間實施類型約束。在List<V>中，類型參數(shù)V出現(xiàn)在get()、add()、contains()等方法的簽名中。 當(dāng)創(chuàng)建一個Map<K, V>類型的變量時，您就在方法之間宣稱一個類型約束。您傳遞給add()的值將與get()返回的值的類型相同。
類似地，之所以聲明泛型方法，一般是因為您想要在該方法的多個參數(shù)之間宣稱一個類型約束。例如，下面代碼中的ifThenElse()方法，根據(jù)它的第一個參數(shù)的布爾值，它將返回第二個或第三個參數(shù)：

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

為什么您選擇使用泛型方法，而不是將類型T添加到類定義呢？（至少）有兩種情況應(yīng)該這樣做：

* 當(dāng)泛型方法是靜態(tài)的時，這種情況下不能使用類類型參數(shù)。

* 當(dāng) T 上的類型約束對于方法真正是局部的時，這意味著沒有在相同類的另一個 方法簽名中使用相同 類型 T 的約束。通過使得泛型方法的類型參數(shù)對于方法是局部的，可以簡化封閉類型的簽名。

有限制類型

在前一屏泛型方法 的例子中，類型參數(shù)V是無約束的或無限制的類型。有時在還沒有完全指定類型參數(shù)時，需要對類型參數(shù)指定附加的約束。

考慮例子Matrix類，它使用類型參數(shù)V，該參數(shù)由Number類來限制：

public class Matrix<V extends Number> { ... } 

編譯器允許您創(chuàng)建Matrix<Integer>或Matrix<Float>類型的變量，但是如果您試圖定義 Matrix<String>類型的變量，則會出現(xiàn)錯誤。類型參數(shù)V被判斷為由Number限制。在沒有類型限制時，假設(shè)類型參數(shù)由 Object限制。這就是為什么前一屏泛型方法 中的例子，允許List.get()在List<?>上調(diào)用時返回Object，即使編譯器不知道類型參數(shù)V的類型。

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

最新評論