Java泛型詳解,通俗易懂的寫法

我們知道,使用變量之前要定義,定義一個變量時必須要指明它的數據類型,什麼樣的數據類型賦給什麼樣的值。

假如我們現在要定義一個類來表示座標,要求座標的數據類型可以是整數、小數和字符串,例如:
  • x = 10、y = 10
  • x = 12.88、y = 129.65
  • x = "東京180度"、y = "北緯210度"

針對不同的數據類型,除了藉助方法重載,還可以藉助自動裝箱和向上轉型。我們知道,基本數據類型可以自動裝箱,被轉換成對應的包裝類;Object 是所有類的祖先類,任何一個類的實例都可以向上轉型爲 Object 類型,例如:
  • int --> Integer --> Object
  • double -->Double --> Object
  • String --> Object

這樣,只需要定義一個方法,就可以接收所有類型的數據。請看下面的代碼:
  1. public class Demo {
  2.     public static void main(String[] args){
  3.         Point p = new Point();
  4.         p.setX(10);  // int -> Integer -> Object
  5.         p.setY(20);
  6.         int x = (Integer)p.getX();  // 必須向下轉型
  7.         int y = (Integer)p.getY();
  8.         System.out.println("This point is:" + x + ", " + y);
  9.        
  10.         p.setX(25.4);  // double -> Integer -> Object
  11.         p.setY("東京180度");
  12.         double m = (Double)p.getX();  // 必須向下轉型
  13.         double n = (Double)p.getY(); // 運行期間拋出異常
  14.         System.out.println("This point is:" + m + ", " + n);
  15.     }
  16. }
  17. class Point{
  18.     Object x = 0;
  19.     Object y = 0;
  20.     public Object getX() {
  21.         return x;
  22.     }
  23.     public void setX(Object x) {
  24.         this.x = x;
  25.     }
  26.     public Object getY() {
  27.         return y;
  28.     }
  29.     public void setY(Object y) {
  30.         this.y = y;
  31.     }
  32. }
上面的代碼中,生成座標時不會有任何問題,但是取出座標時,要向下轉型,在 Java多態對象的類型轉換 一文中我們講到,向下轉型存在着風險,而且編譯期間不容易發現,只有在運行期間纔會拋出異常,所以要儘量避免使用向下轉型。運行上面的代碼,第12行會拋出 java.lang.ClassCastException 異常。

那麼,有沒有更好的辦法,既可以不使用重載(有重複代碼),又能把風險降到最低呢?

有,可以使用泛型類(Java Class),它可以接受任意類型的數據。所謂“泛型”,就是“寬泛的數據類型”,任意的數據類型。

更改上面的代碼,使用泛型類:
  1. public class Demo {
  2.     public static void main(String[] args){
  3.         // 實例化泛型類
  4.         Point<Integer, Integer> p1 = new Point<Integer, Integer>();
  5.         p1.setX(10);
  6.         p1.setY(20);
  7.         int x = p1.getX();
  8.         int y = p1.getY();
  9.         System.out.println("This point is:" + x + ", " + y);
  10.        
  11.         Point<Double, String> p2 = new Point<Double, String>();
  12.         p2.setX(25.4);
  13.         p2.setY("東京180度");
  14.         double m = p2.getX();
  15.         String n = p2.getY();
  16.         System.out.println("This point is:" + m + ", " + n);
  17.     }
  18. }
  19. // 定義泛型類
  20. class Point<T1, T2>{
  21.     T1 x;
  22.     T2 y;
  23.     public T1 getX() {
  24.         return x;
  25.     }
  26.     public void setX(T1 x) {
  27.         this.x = x;
  28.     }
  29.     public T2 getY() {
  30.         return y;
  31.     }
  32.     public void setY(T2 y) {
  33.         this.y = y;
  34.     }
  35. }
運行結果:
This point is:10, 20
This point is:25.4, 東京180度

與普通類的定義相比,上面的代碼在類名後面多出了 <T1, T2>,T1, T2 是自定義的標識符,也是參數,用來傳遞數據的類型,而不是數據的值,我們稱之爲類型參數。在泛型中,不但數據的值可以通過參數傳遞,數據的類型也可以通過參數傳遞。T1, T2 只是數據類型的佔位符,運行時會被替換爲真正的數據類型。

傳值參數(我們通常所說的參數)由小括號包圍,如 (int x, double y),類型參數(泛型參數)由尖括號包圍,多個參數由逗號分隔,如 <T> 或 <T, E>。

類型參數需要在類名後面給出。一旦給出了類型參數,就可以在類中使用了。類型參數必須是一個合法的標識符,習慣上使用單個大寫字母,通常情況下,K 表示鍵,V 表示值,E 表示異常或錯誤,T 表示一般意義上的數據類型。

泛型類在實例化時必須指出具體的類型,也就是向類型參數傳值,格式爲:
    className variable<dataType1, dataType2> = new className<dataType1, dataType2>();
也可以省略等號右邊的數據類型,但是會產生警告,即:
    className variable<dataType1, dataType2> = new className();

因爲在使用泛型類時指明瞭數據類型,賦給其他類型的值會拋出異常,既不需要向下轉型,也沒有潛在的風險,比本文一開始介紹的自動裝箱和向上轉型要更加實用。

注意:
  • 泛型是 Java 1.5 的新增特性,它以C++模板爲參照,本質是參數化類型(Parameterized Type)的應用。
  • 類型參數只能用來表示引用類型,不能用來表示基本類型,如  int、double、char 等。但是傳遞基本類型不會報錯,因爲它們會自動裝箱成對應的包裝類。

泛型方法

除了定義泛型類,還可以定義泛型方法,例如,定義一個打印座標的泛型方法:
  1. public class Demo {
  2. public static void main(String[] args){
  3. // 實例化泛型類
  4. Point<Integer, Integer> p1 = new Point<Integer, Integer>();
  5. p1.setX(10);
  6. p1.setY(20);
  7. p1.printPoint(p1.getX(), p1.getY());
  8. Point<Double, String> p2 = new Point<Double, String>();
  9. p2.setX(25.4);
  10. p2.setY("東京180度");
  11. p2.printPoint(p2.getX(), p2.getY());
  12. }
  13. }
  14. // 定義泛型類
  15. class Point<T1, T2>{
  16. T1 x;
  17. T2 y;
  18. public T1 getX() {
  19. return x;
  20. }
  21. public void setX(T1 x) {
  22. this.x = x;
  23. }
  24. public T2 getY() {
  25. return y;
  26. }
  27. public void setY(T2 y) {
  28. this.y = y;
  29. }
  30. // 定義泛型方法
  31. public <T1, T2> void printPoint(T1 x, T2 y){
  32. T1 m = x;
  33. T2 n = y;
  34. System.out.println("This point is:" + m + ", " + n);
  35. }
  36. }
運行結果:
This point is:10, 20
This point is:25.4, 東京180度

上面的代碼中定義了一個泛型方法 printPoint(),既有普通參數,也有類型參數,類型參數需要放在修飾符後面、返回值類型前面。一旦定義了類型參數,就可以在參數列表、方法體和返回值類型中使用了。

與使用泛型類不同,使用泛型方法時不必指明參數類型,編譯器會根據傳遞的參數自動查找出具體的類型。泛型方法除了定義不同,調用就像普通方法一樣。 

注意:泛型方法與泛型類沒有必然的聯繫,泛型方法有自己的類型參數,在普通類中也可以定義泛型方法。泛型方法 printPoint() 中的類型參數 T1, T2 與泛型類 Point 中的 T1, T2 沒有必然的聯繫,也可以使用其他的標識符代替:
  1. public static <V1, V2> void printPoint(V1 x, V2 y){
  2. V1 m = x;
  3. V2 n = y;
  4. System.out.println("This point is:" + m + ", " + n);
  5. }

泛型接口

在Java中也可以定義泛型接口,這裏不再贅述,僅僅給出示例代碼:
  1. public class Demo {
  2. public static void main(String arsg[]) {
  3. Info<String> obj = new InfoImp<String>("www.weixueyuan.net");
  4. System.out.println("Length Of String: " + obj.getVar().length());
  5. }
  6. }
  7. //定義泛型接口
  8. interface Info<T> {
  9. public T getVar();
  10. }
  11. //實現接口
  12. class InfoImp<T> implements Info<T> {
  13. private T var;
  14. // 定義泛型構造方法
  15. public InfoImp(T var) {
  16. this.setVar(var);
  17. }
  18. public void setVar(T var) {
  19. this.var = var;
  20. }
  21. public T getVar() {
  22. return this.var;
  23. }
  24. }
運行結果:
Length Of String: 18

類型擦除

如果在使用泛型時沒有指明數據類型,那麼就會擦除泛型類型,請看下面的代碼:
  1. public class Demo {
  2. public static void main(String[] args){
  3. Point p = new Point(); // 類型擦除
  4. p.setX(10);
  5. p.setY(20.8);
  6. int x = (Integer)p.getX(); // 向下轉型
  7. double y = (Double)p.getY();
  8. System.out.println("This point is:" + x + ", " + y);
  9. }
  10. }
  11. class Point<T1, T2>{
  12. T1 x;
  13. T2 y;
  14. public T1 getX() {
  15. return x;
  16. }
  17. public void setX(T1 x) {
  18. this.x = x;
  19. }
  20. public T2 getY() {
  21. return y;
  22. }
  23. public void setY(T2 y) {
  24. this.y = y;
  25. }
  26. }
運行結果:
This point is:10, 20.8

因爲在使用泛型時沒有指明數據類型,爲了不出現錯誤,編譯器會將所有數據向上轉型爲 Object,所以在取出座標使用時要向下轉型,這與本文一開始不使用泛型沒什麼兩樣。

限制泛型的可用類型

在上面的代碼中,類型參數可以接受任意的數據類型,只要它是被定義過的。但是,很多時候我們只需要一部分數據類型就夠了,用戶傳遞其他數據類型可能會引起錯誤。例如,編寫一個泛型函數用於返回不同類型數組(Integer 數組、Double 數組、Character 數組等)中的最大值:
  1. public <T> T getMax(T array[]){
  2. T max = null;
  3. for(T element : array){
  4. max = element.doubleValue() > max.doubleValue() ? element : max;
  5. }
  6. return max;
  7. }
上面的代碼會報錯,doubleValue() 是 Number 類的方法,不是所有的類都有該方法,所以我們要限制類型參數 T,讓它只能接受 Number 及其子類(Integer、Double、Character 等)。

通過 extends 關鍵字可以限制泛型的類型,改進上面的代碼:
  1. public <T extends Number> T getMax(T array[]){
  2. T max = null;
  3. for(T element : array){
  4. max = element.doubleValue() > max.doubleValue() ? element : max;
  5. }
  6. return max;
  7. }
<T extends Number> 表示 T 只接受 Number 及其子類,傳入其他類型的數據會報錯。這裏的限定使用關鍵字 extends,後面可以是類也可以是接口。但這裏的 extends 已經不是繼承的含義了,應該理解爲 T 是繼承自 Number 類的類型,或者 T 是實現了 XX 接口的類型。

注意:一般的應用開發中泛型使用較少,多用在框架或者庫的設計中,這裏不再深入講解,主要讓大家對泛型有所認識,爲後面的教程做鋪墊。
發佈了54 篇原創文章 · 獲贊 70 · 訪問量 33萬+
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章