泛型的初認識

1. 泛型是在JDK1.5之后增加的新功能。泛型（Generic）
2. 泛型可以解決數據類型的安全性問題，在類的聲明時通過一個標示表示類中某個屬性的類型或者是某個方法的返回值及參數類型。
3. 大致格式：
   • 訪問權限 class 類名稱 <泛型,泛型,...> {
     屬性
     方法
     }
4. 對象的創建: 類名稱<具體類型> 對象名稱 = new 類名稱<具體類型>();

• 將上篇泛型認識前篇中的 Point 類用泛型優化

class Point<T>{
private T x;
private T y;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
public class Generics {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<Integer> point = new Point<Integer>();
point.setX(10);
point.setY(29);
System.out.println("打印坐標:"+
point.getX()+","+point.getY());
}
}

通過使用泛型的例子與上篇做相應代碼比較可發現，在創建對象初始化坐標時比較方便，需要什么類型數據的坐標，直接在 <> 類加入相應的類名就行。

- 指定多個泛型，只需在尖括號 <> 中用逗號“,”分開就行。例如：

    ```
class Demo<T,K>{
    private T take;
    private K key;        
}

泛型的構造方法

• 構造方法可以為類中的屬性初始化，那么如果類中的屬性通過泛型指定，又需要構造方法來設置其內容的時候，那么構造方法的定語與普通類的構造方法并無大同，不需要像聲明類那樣指定泛型。
  • 在上訴代碼 泛型類 Point 中加入構造方法:

public Point(T x,T y){
    this.x = x;
    this.y = y;
}

- 在對象實例化時使用構造方法：
```

Point<String> point1 = new Point<String>("經度1","緯度2")；
```

泛型 - 通配符

class Info<T>{
    private T key;
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
    @Override
    public String toString(){
        return this.getKey().toString();
    }
}

public class Generics2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Info<String> info = new Info<String>();
        info.setKey("Java學習");
        read(info);
    }
    public static void read(Info<?> t) {
        //這里用 ？通配符代表任意類型，使用Object會出錯，不寫<?>會有警告
        System.out.println(t.toString());
    }
}

泛型接口

• 泛型接口的創建于泛型類的創界并無大同，只是將 class 變為 interface, 但是實現接口的類必須將接口的方法實現。

泛型方法

• 泛型方法與泛型類并沒有必然的聯系，泛型方法有自己的類型參數，在普通類中也可以定義泛型方法。泛型方法中的T1、T2與泛型類中的T1、T2沒有必然的聯系，也可以使用其他的標識符來代替。
• 泛型方法中可以定義泛型參數，此時參數的類型就是傳入的數據類型

class Gener{
    //泛型方法 返回一 T 類型的數據 
    public <T> T returnT(T t) { 
        return t;    
        }
}
public class Generics3 {

    public static void main(String[] args) {
        Gener gener = new Gener();
        //泛型方法的調用方便傳入任意類型的數據
        String str  = gener.returnT("Java學習");
        System.out.println(str);
        int i = gener.returnT(10);
        System.out.println(i);
    }
}

泛型數組

• 在創建一個泛型方法時，也可以傳遞或者返回一個泛型數組

class Gener{
    //傳遞一個泛型數組
    public <T> void returnT(T t[]) { 
            for (int i = 0; i < t.length; i++) {
                System.out.print(t[i]);
            }
        }
}
public class Generics3 {

    public static void main(String[] args) {
        Gener gener = new Gener();
        String arr[] ={"Java","學","習"};
        gener.returnT(arr);
    }
}

泛型摩擦

• 如在定義某一個泛型類，在實例化過程中，沒有指明具體類型，那么就是自動擦除泛型類型。編譯器就將生成一種與泛型類同名的原始類，但是類型參數都被刪除了。

總結 - 泛型的好處

1. 類型安全
2. 消除強制類型轉換
3. 潛在性能收益