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

每博一文案

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

1. 泛型概述

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

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

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

泛型的設計背景

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

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

2. 為什麼要使用泛型

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

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

如下舉例：

沒有使用泛型

我們建立一個 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. 總結：

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

10. 最後：

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

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