Java中的枚舉與泛型的區別有哪些

這篇文章給大家介紹Java中的枚舉與泛型的區別有哪些，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

詳解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） 構造器只是在構造枚舉值的時候被調用。

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的常量而已。 但枚舉類的方法和數據域可以允許外部訪問。

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（）方法： 比較兩個枚舉類對象的引用。

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

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<&#63;> l) { 
for (Object o : l) 
System.out.println(o); 
} 

上面代碼中的問號是一個類型通配符。它讀作“問號”。List<&#63;>是任何泛型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 &#63; first : second; 
} 

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

* 當泛型方法是靜態的時，這種情況下不能使用類類型參數。

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

有限制類型

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

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

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

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

關于Java中的枚舉與泛型的區別有哪些就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。