程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 具體講授Java的泛型

具體講授Java的泛型

編輯：關於JAVA

具體講授Java的泛型。本站提示廣大學習愛好者：（具體講授Java的泛型）文章只能為提供參考，不一定能成為您想要的結果。以下是具體講授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

如許，只須要界說一個辦法，便可以吸收一切類型的數據。請看上面的代碼：

public class Demo {
  public static void main(String[] args){
    Point p = new Point();
    p.setX(10); // int -> Integer -> Object
    p.setY(20);
    int x = (Integer)p.getX(); // 必需向下轉型
    int y = (Integer)p.getY();
    System.out.println("This point is：" + x + ", " + y);
    
    p.setX(25.4); // double -> Integer -> Object
    p.setY("東京180度");
    double m = (Double)p.getX(); // 必需向下轉型
    double n = (Double)p.getY(); // 運轉時代拋出異常
    System.out.println("This point is：" + m + ", " + n);
  }
}
class Point{
  Object x = 0;
  Object y = 0;
  public Object getX() {
    return x;
  }
  public void setX(Object x) {
    this.x = x;
  }
  public Object getY() {
    return y;
  }
  public void setY(Object y) {
    this.y = y;
  }
}

下面的代碼中，生成坐標時不會有任何成績，然則掏出坐標時，要向下轉型，在 Java多態對象的類型轉換一文中我們講到，向下轉型存在著風險，並且編譯時代不輕易發明，只要在運轉時代才會拋出異常，所以要盡可能防止應用向下轉型。運轉下面的代碼，第12行會拋出 java.lang.ClassCastException 異常。

那末，有無更好的方法，既可以不應用重載（有反復代碼），又能把風險降到最低呢？

有，可使用泛型類(Java Class)，它可以接收隨意率性類型的數據。所謂“泛型”，就是“廣泛的數據類型”，隨意率性的數據類型。

更改下面的代碼，應用泛型類：

public class Demo {
  public static void main(String[] args){
    // 實例化泛型類
    Point<Integer, Integer> p1 = new Point<Integer, Integer>();
    p1.setX(10);
    p1.setY(20);
    int x = p1.getX();
    int y = p1.getY();
    System.out.println("This point is：" + x + ", " + y);
    
    Point<Double, String> p2 = new Point<Double, String>();
    p2.setX(25.4);
    p2.setY("東京180度");
    double m = p2.getX();
    String n = p2.getY();
    System.out.println("This point is：" + m + ", " + n);
  }
}
// 界說泛型類
class Point<T1, T2>{
  T1 x;
  T2 y;
  public T1 getX() {
    return x;
  }
  public void setX(T1 x) {
    this.x = x;
  }
  public T2 getY() {
    return y;
  }
  public void setY(T2 y) {
    this.y = y;
  }
}

運轉成果：

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 等。然則傳遞根本類型不會報錯，由於它們會主動裝箱成對應的包裝類。
泛型辦法

除界說泛型類，還可以界說泛型辦法，例如，界說一個打印坐標的泛型辦法：

public class Demo {
  public static void main(String[] args){
    // 實例化泛型類
    Point<Integer, Integer> p1 = new Point<Integer, Integer>();
    p1.setX(10);
    p1.setY(20);
    p1.printPoint(p1.getX(), p1.getY());
    
    Point<Double, String> p2 = new Point<Double, String>();
    p2.setX(25.4);
    p2.setY("東京180度");
    p2.printPoint(p2.getX(), p2.getY());
  }
}
// 界說泛型類
class Point<T1, T2>{
  T1 x;
  T2 y;
  public T1 getX() {
    return x;
  }
  public void setX(T1 x) {
    this.x = x;
  }
  public T2 getY() {
    return y;
  }
  public void setY(T2 y) {
    this.y = y;
  }
  
  // 界說泛型辦法
  public <T1, T2> void printPoint(T1 x, T2 y){
    T1 m = x;
    T2 n = y;
    System.out.println("This point is：" + m + ", " + n);
  }
}

運轉成果：

This point is：10, 20
This point is：25.4, 東京180度

下面的代碼中界說了一個泛型辦法 printPoint()，既有通俗參數，也有類型參數，類型參數須要放在潤飾符前面、前往值類型後面。一旦界說了類型參數，便可以在參數列表、辦法體和前往值類型中應用了。

與應用泛型類分歧，應用泛型辦法時不用指明參數類型，編譯器會依據傳遞的參數主動查找出詳細的類型。泛型辦法除界說分歧，挪用就像通俗辦法一樣。

留意：泛型辦法與泛型類沒有必定的接洽，泛型辦法有本身的類型參數，在通俗類中也能夠界說泛型辦法。泛型辦法 printPoint() 中的類型參數 T1, T2 與泛型類 Point 中的 T1, T2 沒有必定的接洽，也能夠應用其他的標識符取代：

public static <V1, V2> void printPoint(V1 x, V2 y){
  V1 m = x;
  V2 n = y;
  System.out.println("This point is：" + m + ", " + n);
}

泛型接口

在Java中也能夠界說泛型接口，這裡不再贅述，僅僅給出示例代碼：

public class Demo {
  public static void main(String arsg[]) {
    Info<String> obj = new InfoImp<String>("www.weixueyuan.net");
    System.out.println("Length Of String: " + obj.getVar().length());
  }
}
//界說泛型接口
interface Info<T> {
  public T getVar();
}
//完成接口
class InfoImp<T> implements Info<T> {
  private T var;
  // 界說泛型結構辦法
  public InfoImp(T var) {
    this.setVar(var);
  }
  public void setVar(T var) {
    this.var = var;
  }
  public T getVar() {
    return this.var;
  }
}

運轉成果：

Length Of String: 18

類型擦除

假如在應用泛型時沒有指明數據類型，那末就會擦除泛型類型，請看上面的代碼：

public class Demo {
  public static void main(String[] args){
    Point p = new Point(); // 類型擦除
    p.setX(10);
    p.setY(20.8);
    int x = (Integer)p.getX(); // 向下轉型
    double y = (Double)p.getY();
    System.out.println("This point is：" + x + ", " + y);
  }
}
class Point<T1, T2>{
  T1 x;
  T2 y;
  public T1 getX() {
    return x;
  }
  public void setX(T1 x) {
    this.x = x;
  }
  public T2 getY() {
    return y;
  }
  public void setY(T2 y) {
    this.y = y;
  }
}

運轉成果：

This point is：10, 20.8

由於在應用泛型時沒有指明數據類型，為了不湧現毛病，編譯器會將一切數據向上轉型為 Object，所以在掏出坐標應用時要向下轉型，這與本文一開端不應用泛型沒甚麼兩樣。
限制泛型的可用類型

在下面的代碼中，類型參數可以接收隨意率性的數據類型，只需它是被界說過的。然則，許多時刻我們只須要一部門數據類型就夠了，用戶傳遞其他數據類型能夠會惹起毛病。例如，編寫一個泛型函數用於前往分歧類型數組（Integer 數組、Double 數組、Character 數組等）中的最年夜值：

public <T> T getMax(T array[]){
  T max = null;
  for(T element : array){
    max = element.doubleValue() > max.doubleValue() ? element : max;
  }
  return max;
}

下面的代碼會報錯，doubleValue() 是 Number 類的辦法，不是一切的類都有該辦法，所以我們要限制類型參數 T，讓它只能接收 Number 及其子類（Integer、Double、Character 等）。

經由過程 extends 症結字可以限制泛型的類型，改良下面的代碼：

public <T extends Number> T getMax(T array[]){
  T max = null;
  for(T element : array){
    max = element.doubleValue() > max.doubleValue() ? element : max;
  }
  return max;
}

<T extends Number> 表現 T 只接收 Number 及其子類，傳入其他類型的數據會報錯。這裡的限制應用症結字 extends，前面可所以類也能夠是接口。但這裡的 extends 曾經不是繼續的寄義了，應當懂得為 T 是繼續自 Number 類的類型，或許 T 是完成了 XX 接口的類型。

類型參數的規模

在泛型中，假如纰謬類型參數加以限制，它便可以接收隨意率性的數據類型，只需它是被界說過的。然則，許多時刻我們只須要一部門數據類型就夠了，用戶傳遞其他數據類型能夠會惹起毛病。例如，編寫一個泛型函數用於前往分歧類型數組（Integer 數組、Double 數組等）中的最年夜值：

public <T> T getMax(T array[]){
  T max = null;
  for(T element : array){
    max = element.doubleValue() > max.doubleValue() ? element : max;
  }
  return max;
}

下面的代碼會報錯，doubleValue() 是 Number 類及其子類的辦法，不是一切的類都有該辦法，所以我們要限制類型參數 T，讓它只能接收 Number 及其子類（Integer、Double、Character 等）。

經由過程 extends 症結字可以限制泛型的類型的下限，改良下面的代碼：

public <T extends Number> T getMax(T array[]){
  T max = null;
  for(T element : array){
    max = element.doubleValue() > max.doubleValue() ? element : max;
  }
  return max;
}

<T extends Number> 表現 T 只接收 Number 及其子類，傳入其他類型的數據會報錯。這裡的限制應用症結字 extends，前面可所以類也能夠是接口。假如是類，只能有一個；然則接口可以有多個，並以“&”分隔，例如 <T extends Interface1 & Interface2>。

這裡的 extends 症結字已不再是繼續的寄義了，應當懂得為 T 是繼續自 Number 類的類型，或許 T 是完成了 XX 接口的類型。