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

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

如下舉例：

沒有使用泛型

我們創建一個 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. 最后：

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

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543069.html

標籤：其他

上一篇：ElasticSearch分布式搜索引擎——從入門到精通

下一篇：《分布式技術原理與演算法決議》學習筆記Day02

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