Java JDK1.5： 泛型 新特性的講解說明

Java JDK1.5： 泛型 新特性的講解說明

每博一文案

聽到過這樣一句話：“三觀沒有標準。在烏鴉的世界裡，天鵝也有罪。”
環境、閱歷的不同，造就了每個人獨有的世界觀、人生觀、價值觀。
三觀並無對錯高下，只有同與不同。恰如飛鳥不用和游魚同行，高山不必同流水相逢。
總用自己的尺子去度量別人，無疑是一種狹隘。面對不同時，只有懂得尊重對方，才能跳出固有的認知，看得更高更遠。
這個世界上沒有標準答案，人不是隻有一種活法。

@

目錄

• Java JDK1.5： 泛型 新特性的講解說明
• 每博一文案
• 1. 泛型概述
• 2. 為什麼要使用泛型
• 3. 集合中使用泛型
• 4. 自定義泛型結構
  • 4.1 輸入引數命名約定
  • 4.2 自定義泛型結構的介面
  • 4.3 自定義泛型結構的類
    • 4.3.1 含有泛型的類例項化物件
  • 4.4 自定義泛型結構的方法
• 5. 泛型在繼承上的體現
• 6. <泛型> 中的 萬用字元
  • 6.1 萬用字元的使用：注意點
  • 6.2 有限制的萬用字元
    • 6.2.1 無界萬用字元
    • 6.2.2 上界萬用字元
    • 6.2.3 下界萬用字元
• 7. 對泛型的限制(泛型的使用上的注意事項)
• 8. 泛型應用舉例
• 9. 總結：
• 10. 最後：

1. 泛型概述

在任何不重要的軟體專案中，錯誤都只是生活中的事實。 仔細的計劃，程式設計和測試可以幫助減少他們的普遍性，但不知何故，在某個地方，他們總是會找到一種方法來進入你的程式碼。 隨著新功能的推出以及您的程式碼庫規模和複雜性的增加，這一點變得尤為明顯。

幸運的是，一些錯誤比其他錯誤更容易被發現。例如，編譯時錯誤可以在早期發現; 你可以使用編譯器的錯誤資訊來找出問題所在，然後修正它。執行時錯誤，然而，可能是更多的問題; 它們並不總是立即出現，而且當它們這樣做時，它可能在程式中的某一點遠離問題的實際原因。

泛型透過在編譯時檢測更多的錯誤來增加程式碼的穩定性。

• 泛型的設計背景

集合容器類在設計階段/宣告階段不能確定這個容器到底實際存的是什麼型別的物件，所以在JDK1.5之前只能把元素型別設計為 Object，JDK1.5 之後使用泛型來 解決。因為這個時候除了元素的型別不確定，其他的部分是確定的，例如關於 這個元素如何儲存，如何管理等是確定的，因此此時把元素的型別設計成一個引數，這個型別引數叫做泛型。Collection，List，ArrayList 這個就是型別引數，即泛型。

• 泛型的概述
  • 所謂的泛型，就是允許在定義類，介面時透過一個標識<T>類中某個屬性的型別或者時某個方法的返回值以及引數型別。或者換句話說：就是限定類/介面/方法(引數/返回值)的型別。特別的就是限定集合中儲存的資料型別。這個型別引數將在使用時(例如：繼承或實現這個介面，用這個型別宣告變數，建立物件時) 確定(即傳入實際的型別引數，也稱為 “型別實參”)。
  • 從 JDK1.5 以後，java 引入了 “引數化型別 (Parameterized type)” 的概念，允許我們在建立集合時再指定集合元素的型別，正如： List<String> ，這表明該 List 集合只能儲存 字串String型別的物件 。
  • JDK1.5 改寫了集合框架中全部介面和類，為這些介面，類增加了泛型支援，從而可以在宣告集合變數，建立集合物件時傳入 型別實參。

2. 為什麼要使用泛型

那麼為什麼要有泛型呢，直接Object 不是也可以儲存資料嗎？

1. 解決元素儲存的安全性問題，好比商品，藥品標籤，不會弄錯
2. 解決獲取資料元素時，需要型別強制轉換的問題，好比不用每回拿藥，藥品都要辨別，是否拿錯誤。

如下舉例：

沒有使用泛型

我們建立一個 ArrayList 集合不使用泛型，預設儲存的是 Object 型別，用來儲存 學生的成績 int 型別，新增成績時不小心新增了

學生的姓名，因為該集合沒有使用泛型，預設是Object 型別，什麼都可以儲存，所以也把這個輸入錯誤的 學生姓名給儲存進去了。

當我們把 ArrayList 集合當中的儲存的資料取出 (強制轉換為 int 型別的資料成績時)，報異常：java.lang.ClassCastException 型別轉換異常。因為你其中集合當中儲存了一個學生的姓名，String 是無法強制轉換成 int 型別的。

import java.util.ArrayList;

public class GenericTest {
    // 沒有使用泛型
    public static void main(String[] args) {
        // 定義了泛型沒有使用的話，預設是 Object 型別儲存
        ArrayList arrayList = new ArrayList();

        // 新增成績
        arrayList.add(99);
        arrayList.add(89);
        arrayList.add(79);

        // 問題一:儲存的型別不安全
        // 不小心新增了一個學生的姓名
        arrayList.add("Tom");

        for (Object o : arrayList) {
            // 問題二: 強轉時，可能出現ClassCastException 異常
            int stuScore = (Integer)o;  // 因為你儲存的型別可能與強制轉換的型別，沒有繼承關鍵，例項關係
            // 導致轉換失敗.
            System.out.println(stuScore);
        }
    }
}

使用了泛型

將 ArrayLsit 集合定義為 ArrayList<Integer> 使用上泛型，限定了該集合只能儲存 Integer 型別的資料，其它型別的無法存入進到集合當中，編譯的時候就會報錯。

import java.util.ArrayList;

public class GenericTest {
    // 使用上泛型
    public static void main(String[] args) {
        // 泛型限定了儲存型別，泛型指定定義引用型別，基本資料型別不行
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        // 使用了泛型: 就會進行型別檢查，保證資料的安全
        arrayList.add(99);  // 包裝類，自動裝箱
        arrayList.add(78);
        arrayList.add(76);
        arrayList.add(89);
        arrayList.add(88);

        // arrayList.add("Tom"); // 儲存不符合泛型的資料，編譯無法透過。
        for (Integer integer : arrayList) {
            int stuScore = integer;  // 不需要強制轉換自動拆箱

            System.out.println(stuScore);
        }
    }

}

Java泛型可以保證如果程式在編譯時沒有發出警告，執行時就不會產生 java.lang.ClassCastException異常。同時程式碼更加簡潔，健壯 。

簡而言之，在定義類，介面和方法時，泛型使 型別（類和介面）成為引數。 就像方法宣告中使用的更熟悉的 形式引數 一樣，型別引數為您提供了一種方法， 讓您在不同的輸入中重用相同的程式碼。區別在於形式引數的輸入是值，而型別引數的輸入是型別。

使用泛型的程式碼比非泛型程式碼有許多優點：

• 編譯時更強大的型別檢查。

  Java 編譯器將強型別檢查應用於通用程式碼，並在程式碼違反型別安全性時發出錯誤。修復編譯時錯誤比修復執行時錯誤要容易得多。

• 消除強制轉換 。

3. 集合中使用泛型

在 Java SE 7 和更高版本中，只要編譯器可以根據上下文確定或推斷型別引數，就可以用一組空型別引數（<>）替換呼叫泛型類的建構函式所需的型別引數。 這一對尖括號，<>，非正式地稱為鑽石。例如，您可以使用以下語句建立 Box <Integer> 的例項：

List<String> list = new ArrayList<String>();

在 List集合中使用泛型，存取資料

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericTest2 {
    // List 集合中使用泛型存取資料
    public static void main(String[] args) {
        // 使用泛型<String> 限定 List 集合儲存的型別物件，
        // 注意：泛型中只能儲存引用型別的，基本資料型別不可以(int,double)
        List<String> list = new ArrayList<>();

        list.add("Tom");
        list.add("李華");
        list.add("張三");

        Iterator<String> iterator = list.iterator();

        while(iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }

    }
}

---

在Set集合中使用泛型，存取資料

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class GenericTest2 {
    public static void main(String[] args) {
        // Set 集合中使用泛型存取資料
        // 使用泛型<Integer> 限定Set 集合儲存的型別物件
        // 注意：泛型中只能儲存引用型別的，基本資料型別不可以(int,double)
        Set<Integer> set = new HashSet<>();

        set.add(1);
        set.add(2);
        set.add(3);

        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
    }

在 Map 集合中使用泛型存取資料

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class GenericTest2 {
    // Map 集合中使用泛型存取資料
    public static void main(String[] args) {
        // 使用泛型<String,Integer> 限定 Map 集合儲存的型別物件
        // 注意：泛型中只能儲存引用型別的，基本資料型別不可以(int,double) 
        Map<String, Integer> map = new HashMap<>();
        map.put("Tom", 99);
        map.put("李華", 89);
        map.put("張三", 79);

        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            System.out.println(entry.getKey() + "--->" + entry.getValue());

        }
    }
}

泛型是可以被巢狀的，多層巢狀泛型Set<Map.Entry<T>>

Set<Map.Entry<String, Integer>> entries = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
// 這裡泛型巢狀了兩層: Set<Map.Entry<>> 這是一層
//      內部還有一層: Map.Entry<String,Integer> 這是第二層

4. 自定義泛型結構

4.1 輸入引數命名約定

按照慣例，型別引數名稱是單個大寫字母。這與你已經知道的變數命名約定形成了鮮明的對比 ，並且有很好的理由：沒有這個約定，很難區分型別變數和普通類或介面名稱。

最常用的型別引數名稱是：

• E - 元素（由 Java 集合框架廣泛使用）
• K - Key
• N - Number
• T - Type
• V - Value
• S,U,V etc. - 2nd, 3rd, 4th types

4.2 自定義泛型結構的介面

一個泛型介面的定義格式如下：

介面中的泛型可以定義一個，也可以定義多個，多個泛型 T 使用逗號, 分隔開來。

public interface MyGeneric<T1, T2, ..., Tn> {
}

介面中的泛型 T ，可以在抽象方法中應用起來：

在抽象方法中作為 方法值 T

public interface MyGeneric<T> {

    // 定義含有泛型的 T 抽象方法：泛型作為返回值;
    public T fun();
}

在抽象方法中作為 引數 T

public interface MyGeneric<T> {
    // 定義含有泛型的 T 抽象方法： 泛型作為引數
    public void fun2(T t);

}

既作為抽象方法中的返回值 T ，又作為抽象方法中的 引數 T

public interface MyGeneric<T> {
    
    // 定義含有泛型的 T 抽象方法： T 泛型作為返回值，引數
    public T fun3(T t);

}

public interface MyGeneric<T> {

    // 定義含有泛型的 T 抽象方法：泛型作為返回值;
    public T fun();

    // 定義含有泛型的 T 抽象方法： 泛型作為引數
    public void fun2(T t);

    // 定義含有泛型的 T 抽象方法： T 泛型作為返回值，引數
    public T fun3(T t);

}

4.3 自定義泛型結構的類

一個泛型類的定義格式如下：

class name<T1, T2, ..., Tn> { /* ... */ }

由尖括號（<>）分隔的型別引數部分在類名後面。它指定了型別引數（也稱為型別變數）T1，T2，...，和Tn。

要更新 Box 類以使用泛型，可以透過將程式碼 public class Box 更改為 public class Box <T> 來建立泛型型別宣告。 這引入了型別變數 T，可以在類中的任何地方(非靜態方法，屬性，引數，返回值)使用。

把一個集合中的內容限制為一個特定的資料型別，這就是泛型背後的核心思想。

注意：含有泛型的類的構造器的建立，和沒有使用泛型一樣建立構造器，就可以了，不要附加你的奇思妙想

如下：

public class Box<T> {
    
    // 泛型<T> 應用類屬性當中
    T t;

    
    // 無參構造器
    public Box() {
        
    }
    
    // 帶泛型引數構造器
    public Box(T t) {
        this.t = t;
    }
}

具體如下程式碼

public class Box<T> {

    // 泛型<T> 應用類屬性當中
    T t;


    // 無參構造器
    public Box() {

    }

    // 帶泛型引數構造器
    public Box(T t) {
        this.t = t;
    }


    // 泛型<T> 應用到方法返回值中
    public T fun() {
       return null;
    }

    // 泛型<T> 應用到引數當中
    public void fun2(T t) {

    }

    // 泛型<T> 應用到返回值，引數當中
    public T set(T t) {
        return null;
    }


}

注意異常類中不可以使用泛型<T> 編譯無法透過

不可以使用泛型建立陣列，編譯無法透過

但是我們可以用，特殊方法實現如下：透過建立一個 new Object[] 的陣列，再強制轉換為 T[] 泛型陣列,因為泛型預設沒有使用的話，是 Object 型別。

泛型不可以作為例項化物件出現，因為泛型是在例項化的時候才確定該泛型具體的型別是什麼的，如果直接對泛型例項化，你都不知道例項化成什麼型別的物件的。 所以直接編譯無法透過。

如下：

4.3.1 含有泛型的類例項化物件

帶有泛型的例項化：一定要在類名/介面後面指定型別引數的值(型別)。如下:

List<String> list = new ArrayList<String>();

**JDK 7 ** 版本以後可以省略 = 等號右邊的 <>泛型宣告瞭，只要宣告左邊的就可以了。就算你右邊附加上了<>泛型宣告， 預設也是會被省略的。

List<String> list = new ArrayList<>();

注意泛型和集合一樣，只能儲存引用型別的資料，泛型不能用基本資料型別填充，必須使用引用型別填充，這裡包裝類就起到了非常重要的作用了。

4.4 自定義泛型結構的方法

泛型方法 是引入自己的型別引數的方法。這與宣告泛型型別相似，但是型別引數的作用域僅限於宣告它的方法。允許使用靜態和非靜態泛型方法，以及泛型類建構函式。

泛型方法的語法包括一個型別引數列表，裡面的尖括號出現在方法的返回型別之前。對於靜態泛型方法，型別引數部分必須出現在方法的返回型別之前。

泛型方法，與該類是不是含有泛型類無關 ，換句話說：泛型方法所屬的類是不是泛型類都沒有關係，同樣可以定義泛型方法。

定義非靜態泛型方法格式如下：

訪問許可權修飾符 <泛型>(表示泛型方法不可省略) 返回型別 方法名(引數型別 引數名) 丟擲的異常 

public <E> E fun3(E e) {
    return e;
}

定義靜態泛型方法格式如下：在附加上一個 static 靜態修飾，

訪問許可權修飾符 static  <泛型>(表示泛型方法不可省略) 返回型別 方法名(引數型別 引數名) 丟擲的異常 

public static <E> E fun4(E e) {
        System.out.println("靜態：泛型方法，泛型作為返回值，引數"+e);
        return e;
}

package blogs.blog8;

public class GenericTest4 {
    public static void main(String[] args) {
        // 泛型方法的呼叫:


    }

}

class MyClass {

    // 泛型方法，無返回值的
    public <E> void fun() {
        System.out.println("泛型方法，無返回值,無引數的");
    }

    // 泛型方法: 泛型作為引數傳入
    public <E> void fun2(E e) {
        System.out.println("泛型方法，無返回值，有泛型引數"+e);
    }

    // 泛型方法: 泛型作為返回值，和引數
    public <E> E fun3(E e) {
        System.out.println("泛型方法，泛型作為返回值，引數"+e);
        return e;
    }

    public static <E> E fun4(E e) {
        System.out.println("靜態：泛型方法，泛型作為返回值，引數"+e);
        return e;
    }
}

泛型方法的呼叫和沒有普通的方法一樣的方式呼叫，沒有什麼區別，區別是在 JVM 執行編譯的時候的不同。呼叫是一樣的方法如下

package blogs.blog8;



public class GenericTest4 {
    public static void main(String[] args) {
        // 泛型方法的呼叫:
        MyClass myClass = new MyClass();
        myClass.fun();
        myClass.fun2(new String("Hello"));
        String s = myClass.fun3("你好世界");
        System.out.println(s);

        System.out.println("**********");
        String s2 = MyClass.fun4("Hello Wrold");
        System.out.println(s2);


    }

}

class MyClass {

    // 泛型方法，無返回值的
    public <E> void fun() {
        System.out.println("泛型方法，無返回值,無引數的");
    }

    // 泛型方法: 泛型作為引數傳入
    public <E> void fun2(E e) {
        System.out.println("泛型方法，無返回值，有泛型引數"+e);
    }

    // 泛型方法: 泛型作為返回值，和引數
    public <E> E fun3(E e) {
        System.out.println("泛型方法，泛型作為返回值，引數"+e);
        return e;
    }

    public static <E> E fun4(E e) {
        System.out.println("靜態：泛型方法，泛型作為返回值，引數"+e);
        return e;
    }
}

泛型方法在你呼叫的時候，就會推斷出你要 <E> 泛型的具體的型別了。 如下：

5. 泛型在繼承上的體現

關於父類中含有泛型<> 對應的子類的對父類泛型的處理情況：如下

• 父類有泛型，子類繼承父類：不保留父類中的泛型，擦除了父類中的泛型(預設是 Object)

// 父類
class Father<T1,T2> {

}


// 子類沒有保留父類的泛型，擦除了: 等價於class Son extends Father<Object,Object>{}
class Son1 extends Father{

}

• 父類有泛型，子類繼承父類：並指明瞭父類的泛型(具體型別)

注意: 由於子類在繼承泛型的父類/實現的介面時，指明瞭泛型具體是什麼型別，所以例項化子類物件時，不再需要指明泛型了。

但是單獨例項化父類還是要指明其泛型的具體型別的。

// 父類
class Father<T1,T2> {

}

// 子類保留了父類的泛型，並指明瞭父類中泛型的具體型別
class Son2 extends Father<String,Integer> {
    
}

• 父類有泛型，子類繼承父類：並保留了父類的泛型(並沒有指明具體型別)

注意: 因為子類並沒有指明父類泛型的具體型別，所以子類要沿用上父類的泛型<>從而對父類上的泛型(賦予具體型別),不然編譯無法透過。

// 父類
class Father<T1,T2> {

}

// 子類保留了父類的泛型，並沒有指明父類的具體型別
// 注意：因為沒有指明父類泛型的具體型別，所以子類要沿用上父類的泛型<>從而對父類上的泛型(賦予具體型別)
class Son3<T1,T2> extends Father<T1,T2> {

}

• 父類有泛型，子類繼承父類：並保留了父類的泛型(並沒有指明具體型別)，外加子類定義自己獨有的泛型

注意: 因為子類並沒有指明父類泛型的具體型別，所以子類要沿用上父類的泛型<>從而對父類上的泛型(賦予具體型別),不然編譯無法透過。

// 父類
class Father<T1,T2> {

}

// 子類繼承父類：並保留了父類的泛型(並沒有指明具體型別)，外加子類定義自己獨有的泛型
class Son4<T1,T2,E,E2> extends Father<T1,T2> {
    
}

• 父類有泛型，子類繼承父類：並保留了父類的部分泛型(部分指明瞭父類的泛型具體型別，部分沒有指明父類的泛型具體型別)，外加子類定義自己獨有的泛型

注意: 因為子類並沒有指明父類泛型的具體型別，所以子類要沿用上父類的泛型<>從而對父類上的泛型(賦予具體型別),不然編譯無法透過。

// 父類
class Father<T1,T2> {

}

// 父類有泛型，子類繼承父類：並保留了父類的`部分`泛型(部分指明瞭父類的泛型具體型別，部分沒有指明父類的泛型具體型別)，外加子類定義自己獨有的泛型
class Son4K<T2,E,E2> extends Father<String,T2> {
    
}

6. <泛型> 中的 萬用字元

泛型的多型性上的使用

• 注意: ArrayList<String> 和 ArrqayList<Intger> 是兩種不同的型別，雖然它們整體上是都是 ArrayList 集合類，但是所指定的泛型(指明的型別不同，導致儲存的型別不同) ，編譯時被鑑定為了兩種不同的型別，無法相互引用賦值。但是，在執行時只有一個 ArrayList 被載入到 JVM 中，因為類一樣的，所儲存的型別不同而已，類僅僅只會載入一次到i記憶體當中。
• 簡單的說：就是泛型不同的不可以相互引用賦值 ，編譯無法透過。

如下程式碼：

兩個泛型相同的型別可以引用賦值如下

根據上述情況，我們對不同的泛型(具體指明的型別) 需要定義不同的方法了。注意: 如果是的泛型<指明的具體型別>不同是無法過載方法的。

import java.util.ArrayList;
import java.util.List;

public class GenericTest6 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        ArrayList<Integer> arrayList2 = new ArrayList<>();
        
        fun1(arrayList);  // <String>
        fun2(arrayList2); // <Integer>
    }


    public static void fun1(List<String> list) {

    }

    public static void fun2(List<Integer> list) {

    }
}

為了解決上述，因為泛型(指明的具體型別)的不同，而導致的繁瑣操作。Java為程式設計師提供了 萬用字元?

在泛型程式碼中，被稱為萬用字元的是 一個問號（?） 表示未知型別。 萬用字元可用於多種情況：作為引數的型別、欄位或區域性變數;

有時作為返回型別（儘管更好的程式設計實踐更具體）。比如：List ，Map 。List<?> 可以理解為是Lis<String>t、List<Object>等各種泛型List的父類。

萬用字元永遠不會用作泛型方法呼叫，泛型類例項建立或超型別的型別引數。

舉例:

import java.util.ArrayList;
import java.util.List;

public class GenericTest6 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        ArrayList<Integer> arrayList2 = new ArrayList<>();
        ArrayList<?> arrayList3 = new ArrayList<>();
        arrayList3 = arrayList;  // 儘管 <String> 不同，都可以賦值給 <?> 萬用字元
        arrayList3 = arrayList2; // 儘管 <Integer> 不同，都可以賦值給 <?> 萬用字元
    }
}

舉例:

import java.util.ArrayList;
import java.util.List;

public class GenericTest6 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        ArrayList<Integer> arrayList2 = new ArrayList<>();

        fun(arrayList);  // <String>
        fun(arrayList2); // <Integer>
    }

    public static void fun(List<?> list) {

    }
}

對於 List<?>，Map<?,?>，Set<?> 等等物件讀取(新增)資料元素時，永遠時可以新增成功的，因為不管 list<泛型> 中的泛型具體指明的是什麼型別都，它們都是包含了 Object ，都可以被 ? 接受住。

我們可以呼叫 get() 方法並使用其返回值。返回值是一個未知的型別，但是我們知道，它總是一個Object。

如下程式碼:

import java.util.ArrayList;
import java.util.List;

public class GenericTest6 {
    public static void main(String[] args) {
        List<?> list3 = null;
        List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");

        // 將 List<String> 引用賦值給 List<?>
        list3 = list;
        // 獲取值
        Object o = list3.get(0);
        System.out.println(o);
        Object o2 = list3.get(1);
        System.out.println(o2);

        System.out.println("*******************************");

        List<Integer> list2 = new ArrayList<>();
        list2.add(99);
        list2.add(999);

        // 將 List<Integer> 引用賦值給 List<?>
        list3 = list2;
        // 獲取值
        Object o3 = list3.get(0);
        System.out.println(o3);
        Object o4 = list3.get(1);
        System.out.println(o4);


    }
}

對於 List<?>，Map<?,?>，Set<?> 等等物件讀取(新增)資料元素時，報編譯無法透過。因為我們不知道 ？的元素型別，我們不能向其中新增物件。唯一的例外是null，它是所有型別的成員。

將任意元素加入到其中不是型別安全的：

Collection c = new ArrayList();

c.add(new Object()); // 編譯時錯誤

因為我們不知道c的元素型別，我們不能向其中新增物件。add方法有型別引數E作為集合的元素型別。我們傳給add的任何引數都必須是一個未知型別的子類。因為我們不知道那是什麼型別，所以我們無法傳任何東西進去。

舉例:

6.1 萬用字元的使用：注意點

• 注意點1：編譯錯誤：萬用字元不能用在泛型方法宣告上，返回值型別前面也<>不能使用 。

• 注意點2：編譯錯誤：萬用字元不能用在泛型類的宣告上。

• 注意點3：編譯錯誤：不能用在建立物件上，右邊屬於建立集合物件。

6.2 有限制的萬用字元

6.2.1 無界萬用字元

<?> 允許所以泛型的引用呼叫。稱為 無界萬用字元 。上面介紹了，就這裡就不多介紹了。

6.2.2 上界萬用字元

< ? extends XXX> 上限 extends ：使用時指定的型別必須是繼承某個類(XXX)，或者實現了某個介面(X

xX)。 即 <= 。

比如:

< ? extends Person>;  // (無窮小, Person] 只允許泛型為 Person 以及 Person 子類的引用呼叫
< ? extends Comparable>;  // 只允許泛型為實現 Comparable 介面的實現類的引用呼叫

舉例:

package blogs.blog8;

import java.util.ArrayList;
import java.util.List;

public class GenericTest7 {
    public static void main(String[] args) {
        List< ? extends Person> list = null;  // <=
        List<Person> list2 = new ArrayList<>();
        List<Student> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();

        // list 可以存取 <= Person 的型別
        list = list2;
        list = list3;
        list = list4; // 這就Object > Person 不行

    }
}


class Person {

}

class Student extends Person {

}

注意： 同樣 <? extends XXX> 下界萬用字元，的引用不可以新增資料(因為是未知的型別)，但是可以獲取起其中的資料，返回 XXX 最大的。

“寫入” 新增資料，無法寫入

"讀"：獲取資料: 返回對應最大的 XXX

package blogs.blog8;

import java.util.ArrayList;
import java.util.List;

public class GenericTest7 {
    public static void main(String[] args) {
        List< ? extends Person> list = null;  // <=
        List<Person> list2 = new ArrayList<>();
        List<Student> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();
        list3.add(new Student() );

        // list 可以存取 <= Person 的型別
        list = list2;
        list = list3;

        // 獲取資料 “讀”
        Person person = list.get(0);
        System.out.println(person);

    }
}


class Person {

}

class Student extends Person {

}

6.2.3 下界萬用字元

< ? super XXX> 下限 super：使用時指定的型別不能小於操作的類 XXX，即 >=

比如:

< ? super Person>;  // [Person, 無窮大] 只允許泛型為 Person 及  Person父類的引用呼叫

舉例:

注意： 同樣 <? superXXX> 上界萬用字元，的引用不可以新增資料(因為是未知的型別)，但是可以獲取起其中的資料，返回 XXX 最大的。

“寫入” 新增資料，無法寫入

"讀"：獲取資料: 返回對應最大的 Object

package blogs.blog8;

import java.util.ArrayList;
import java.util.List;

public class GenericTest7 {
    public static void main(String[] args) {
        List< ? super Person> list = null;  // >= Person
        List<Person> list2 = new ArrayList<>();
        List<Student> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();
        list3.add(new Student() );

        // list 可以存取 >= Person 的型別
        list = list2;
        list = list4;
        list.add(new Person());  // 小於的可以新增上
        list.add(new Student());

        Object object = list.get(0);
        System.out.println(object);


    }


}


class Person {

}

class Student extends Person {

}

7. 對泛型的限制(泛型的使用上的注意事項)

要有效地使用 Java 泛型，您必須考慮以下限制：

• 注意：泛型不能只能填充引用型別，不可填充基本資料型別。使用包裝類

• 注意：泛型不可以無法建立型別引數的例項 E new () 不可以 編譯無法透過

• 注意：不能宣告型別是型別引數的靜態欄位/靜態方法中(編譯無法透過)，但是可以建立靜態泛型方法。 因為泛型是例項化物件的時候才確定其指明具體型別，而 靜態是在例項化之前的操作。靜態泛型方法是：在呼叫靜態泛型方法的時候泛型才確定指明具體型別的。所以沒問題。

• 注意：不能使用帶有引數化型別的 cast 或 instanceof

• 注意：泛型不能建立引數化型別的陣列

但是我們可以用，特殊方法實現如下：透過建立一個 new Object[] 的陣列，再強制轉換為 T[] 泛型陣列,因為泛型預設沒有使用的話，是 Object 型別。

• 注意：泛型可以用於建立，捕捉或丟擲引數化型別的物件 自定義異常類中不可以用泛型類

• 不能過載每個過載的形式引數型別擦除到相同的原始型別的方法，簡單的說：就是不能透過指明的泛型的不同實現過載的，不滿足過載的要求的

8. 泛型應用舉例

• 定義個泛型類 DAO，在其中定義一個 Map 成員變數，Map 的鍵 為 String 型別，值為 T 型別。

分別建立以下方法：

public void save(String id,T entity)： 儲存 T 型別的物件到 Map 成員 變數中 。

public T get(String id)：從 map 中獲取 id 對應的物件。

public void update(String id,T entity)：替換 map 中 key 為 id 的內容,改為 entity 物件 。

public List list()：返回 map 中存放的所有 T 物件 。

public void delete(String id)：刪除指定 id 物件 。

定義一個 User 類：

該類包含：private 成員變數（int 型別） id，age；（String 型別）name。

定義一個測試類：

建立 DAO 類的物件， 分別呼叫其 save、get、update、list、delete 方 法來操作 User 物件，

使用 Junit 單元測試類進行測試。

DAO類，和 User類

package blogs.blog8;


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;


public class DAO<T> {
    private Map<String, T> map = null;

    public DAO() {
        // 構造器為其Map集合初始化
        this.map = new HashMap<>();
    }

    // 儲存 T 型別的物件到Map成員變數中
    public void save(String id, T entity) {
        map.put(id, entity);
    }

    // 從map中獲取id對應的物件
    public T get(String id) {
        return map.get(id);
    }

    // 替換Map中的 key 為 id 的內容，改為 entity物件
    public void update(String id, T entity) {
        if (map.containsKey(id)) {  // 首先判斷該修改的 key 是否存在，
            // 存在透過 put()新增覆蓋
            map.put(id, entity);
        }
    }

    // 返回map中存放的所以 T 物件
    public List<T> list() {
        Collection<T> values = map.values();
        List<T> list = new ArrayList<T>();
        // 注意了: Collection 是 List 的父類介面，如果List 物件不是 Collection 的例項
        // 是無法將一個父類強制(向下)為子類的，(這裡兩個都是介面，不可能有例項的)
        // 透過取出所以的values 值賦值到一個新建立的 List 物件當中再返回。
        for (T t : values) {
            list.add(t);
        }
        return list;

    }

    // 刪除指定id物件
    public void delete(String id) {
        map.remove(id);
    }
}

class User {
    private int id;
    private int age;
    private String name;

    public User() {

    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 因為儲存的是在Map當中所以，Map當中的Key 儲存物件需要重寫 equals() 和 hashCode() 方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return getId() == user.getId() &&
                getAge() == user.getAge() &&
                Objects.equals(getName(), user.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getId(), getAge(), getName());
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

DAOTest

package blogs.blog8;

import day25.DAOS;
import org.junit.Test;

import java.util.List;

public class DAOTest {
    @Test
    public void test() {
        DAOS<User> dao = new DAOS<User>();

        dao.save("1001",new User(1001,34,"周杰倫"));
        dao.save("1002",new User(1002,20,"昆菱"));
        dao.save("1003",new User(1003,25,"蔡依林"));

        dao.update("1003",new User(1003,30,"萬文山"));

        dao.delete("1002");

        List<User> list = dao.list();
        list.forEach(System.out::println);


    }
}

9. 總結：

1. 泛型是 JDK5.0 的新特性。
2. Java泛型可以保證如果程式在編譯時沒有發出警告，執行時就不會產生ClassCastException異常。同時，程式碼更加簡潔、健壯。
3. 把一個集合中的內容限制為一個特定的資料型別，這就是generics背後的核心思想
4. 泛型只能填充引用型別，基本資料型別不可填充泛型，使用包裝類。
5. 使用泛型的主要優點是能夠在編譯時而不是在執行時檢測錯誤。
6. 泛型如果不指定，將被擦除，泛型對應的型別均按照Object處理，但不等價 於Object。經驗： 泛型要使用一路都用。要不用，一路都不要用。
7. 自定義泛型類，泛型介面，泛型方法。
8. 泛型類在父類上的繼承變化上的使用。
9. 泛型中的萬用字元上的使用：無界萬用字元<?>，上界萬用字元< ? extends XXX> (<=)，下界萬用字元 <? super XXX> (>= )
10. 泛型在使用上的限制以及注意事項。

10. 最後：

限於自身水平，其中存在的錯誤，希望大家給予指教，韓信點兵——多多益善。謝謝大家，江湖再見，後會有期！！！