Java知多少（41）泛型詳解

時間 2019-11-25

標籤 java 多少詳解欄目 Java 简体版

原文原文鏈接

咱們知道，使用變量以前要定義，定義一個變量時必需要指明它的數據類型，什麼樣的數據類型賦給什麼樣的值。

假如咱們如今要定義一個類來表示座標，要求座標的數據類型能夠是整數、小數和字符串，例如：

1 x = 十、y = 10
2 x = 12.8八、y = 129.65
3 x = "東京180度"、y = "北緯210度"

針對不一樣的數據類型，除了藉助方法重載，還能夠藉助自動裝箱和向上轉型。咱們知道，基本數據類型能夠自動裝箱，被轉換成對應的包裝類；Object 是全部類的祖先類，任何一個類的實例均可以向上轉型爲 Object 類型，例如：

1 int --> Integer --> Object
2 double -->Double --> Object
3 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 }

運行結果：html

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        
 9         Point<Double, String> p2 = new Point<Double, String>();
10         p2.setX(25.4);
11         p2.setY("東京180度");
12         p2.printPoint(p2.getX(), p2.getY());
13     }
14 }
15 // 定義泛型類
16 class Point<T1, T2>{
17     T1 x;
18     T2 y;
19     public T1 getX() {
20         return x;
21     }
22     public void setX(T1 x) {
23         this.x = x;
24     }
25     public T2 getY() {
26         return y;
27     }
28     public void setY(T2 y) {
29         this.y = y;
30     }
31    
32     // 定義泛型方法
33     public <T1, T2> void printPoint(T1 x, T2 y){
34         T1 m = x;
35         T2 n = y;
36         System.out.println("This point is：" + m + ", " + n);
37     }
38 }

運行結果：
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 接口的類型。

注意：通常的應用開發中泛型使用較少，多用在框架或者庫的設計中，這裏再也不深刻講解，主要讓你們對泛型有所認識，爲後面的教程作鋪墊。

系列文章：

Java知多少（上）java

Java知多少（中）數組