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 不是也可以存儲資料嗎？

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

如下舉例：

沒有使用泛型

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

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

當我們把 ArrayList 集合當中的存儲的資料取出 (強制轉換為 int 類型的資料成績時)，報異常：

java.lang.ClassCastException

類型轉換異常。因為你其中集合當中存儲了一個學生的姓名，String 是無法強制轉換成 int 類型的。

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

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);
        }
    }
}

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

使用了泛型

将 ArrayLsit 集合定義為

ArrayList<Integer>

使用上泛型，限定了該集合隻能存儲 Integer 類型的資料，其它類型的無法存入進到集合當中，編譯的時候就會報錯。

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

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 JDK1.5：泛型新特性的講解說明

Java泛型可以保證如果程式在編譯時沒有發出警告，運作時就不會産生

java.lang.ClassCastException

異常。同時代碼更加簡潔，健壯。

簡而言之，在定義類，接口和方法時，泛型使類型（類和接口）成為參數。就像方法聲明中使用的更熟悉的形式參數一樣，類型參數為您提供了一種方法，讓您在不同的輸入中重用相同的代碼。差別在于形式參數的輸入是值，而類型參數的輸入是類型。

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

編譯時更強大的類型檢查。

Java 編譯器将強類型檢查應用于通用代碼，并在代碼違反類型安全性時發出錯誤。修複編譯時錯誤比修複運作時錯誤要容易得多。
消除強制轉換。

3. 集合中使用泛型

在 Java SE 7 和更高版本中，隻要編譯器可以根據上下文确定或推斷類型參數，就可以用一組空類型參數（

<>

）替換調用泛型類的構造函數所需的類型參數。這一對尖括号，

<>

，非正式地稱為鑽石。例如，您可以使用以下語句建立

Box <Integer>

的執行個體：

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

在 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);
        }

    }
}

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

在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);
        }
    }

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

在 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());

        }
    }
}

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

泛型是可以被嵌套的，多層嵌套泛型

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 自定義泛型結構的類

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

由尖括号（

<>

）分隔的類型參數部分在類名後面。它指定了類型參數（也稱為類型變量）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> 編譯無法通過

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

不可以使用泛型建立數組，編譯無法通過

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

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

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

泛型不可以作為執行個體化對象出現，因為泛型是在執行個體化的時候才确定該泛型具體的類型是什麼的，如果直接對泛型執行個體化，你都不知道執行個體化成什麼類型的對象的。是以直接編譯無法通過。

如下：

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

4.3.1 含有泛型的類執行個體化對象

帶有泛型的執行個體化：一定要在類名/接口後面指定類型參數的值(類型)。如下:

**JDK 7 ** 版本以後可以省略

等号右邊的 <>泛型聲明了，隻要聲明左邊的就可以了。就算你右邊附加上了<>泛型聲明，預設也是會被省略的。

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

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

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;
    }
}

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

泛型方法在你調用的時候，就會推斷出你要

<E>

泛型的具體的類型了。如下：

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

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記憶體當中。
簡單的說：就是泛型不同的不可以互相引用指派，編譯無法通過。

如下代碼：

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

兩個泛型相同的類型可以引用指派如下

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

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

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

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的父類。

通配符永遠不會用作泛型方法調用，泛型類執行個體建立或超類型的類型參數。

舉例:

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

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> 不同，都可以指派給 <?> 通配符
    }
}

舉例:

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

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);


    }
}

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

對于

List<?>

，

Map<?,?>

，

Set<?>

等等對象**讀取(添加)**資料元素時，報編譯無法通過。因為我們不知道

？

的元素類型，我們不能向其中添加對象。唯一的例外是null，它是所有類型的成員。

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

Collection c = new ArrayList();

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

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

舉例:

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

6.1 通配符的使用：注意點

注意點1：編譯錯誤：通配符不能用在泛型方法聲明上，傳回值類型前面也<>不能使用。

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

注意點2：編譯錯誤：通配符不能用在泛型類的聲明上。

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

注意點3：編譯錯誤：不能用在建立對象上，右邊屬于建立集合對象。

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

6.2 有限制的通配符

6.2.1 無界通配符

<?>

允許是以泛型的引用調用。稱為無界通配符。上面介紹了，就這裡就不多介紹了。

6.2.2 上界通配符

< ? extends XXX>

上限 extends ：使用時指定的類型必須是繼承某個類(XXX)，或者實作了某個接口(X

xX)。即 <= 。

比如:

< ? extends Person>;  // (無窮小, Person] 隻允許泛型為 Person 以及 Person 子類的引用調用
< ? extends Comparable>;  // 隻允許泛型為實作 Comparable 接口的實作類的引用調用

舉例:

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

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 最大的。

“寫入” 添加資料，無法寫入

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

“讀”：擷取資料: 傳回對應最大的 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 {

}

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

6.2.3 下界通配符

< ? super XXX>

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

比如:

舉例:

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

注意：同樣

<? superXXX>

上界通配符，的引用不可以添加資料(因為是未知的類型)，但是可以擷取起其中的資料，傳回 XXX 最大的。

“寫入” 添加資料，無法寫入

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

“讀”：擷取資料: 傳回對應最大的 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 {

}

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

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

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

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

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

注意：泛型不可以無法建立類型參數的執行個體 E new () 不可以編譯無法通過

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

注意：不能聲明類型是類型參數的靜态字段/靜态方法中(編譯無法通過)，但是可以建立靜态泛型方法。因為泛型是執行個體化對象的時候才确定其指明具體類型，而靜态是在執行個體化之前的操作。靜态泛型方法是：在調用靜态泛型方法的時候泛型才确定指明具體類型的。是以沒問題。

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

注意：不能使用帶有參數化類型的 cast 或 instanceof

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

注意：泛型不能建立參數化類型的數組

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

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

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

注意：泛型可以用于建立，捕捉或抛出參數化類型的對象自定義異常類中不可以用泛型類

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

不能重載每個過載的形式參數類型擦除到相同的原始類型的方法，簡單的說：就是不能通過指明的泛型的不同實作重載的，不滿足重載的要求的

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

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);


    }
}

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

9. 總結：

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

10. 最後：

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

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

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