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

来源:https://www.cnblogs.com/TheMagicalRainbowSea/archive/2023/02/05/17093972.html
-Advertisement-
Play Games

Java JDK1.5： 泛型 新特性的講解說明 每博一文案 聽到過這樣一句話：“三觀沒有標準。在烏鴉的世界里，天鵝也有罪。” 環境、閱歷的不同，造就了每個人獨有的世界觀、人生觀、價值觀。 三觀並無對錯高下，只有同與不同。恰如飛鳥不用和游魚同行，高山不必同流水相逢。 總用自己的尺子去度量別人，無疑是 ...


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

  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. 最後：

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

在這裡插入圖片描述


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Odoo 菜單定義和修改學習總結
    odoo菜單定義和修改學習總結 環境 odoo-14.0.post20221212.tar 定義菜單 方式1： <?xml version="1.0"?> <odoo> <menuitem id="root_menu_id" name="TopMenu" web_icon="estate,stati ...
  • day02-REST和SpringMVC映射請求數據
    REST和SpringMVC映射請求數據 7.REST-優雅的url請求風格 7.1REST基本介紹 REST風格詳細介紹 REST：即 Representational State Transfer，表述性狀態傳遞。它結構清晰，同時可以隱藏行為。 通過一個url來直觀展示傳統風格與REST風格的區 ...
  • day01-2-@RequestMapping
    @RequestMapping 1.基本使用 @RequestMapping註解可以指定 控制器（處理器） 的某個方法的請求url 2.@RequestMapping其他使用方式 2.1修飾方法和類 @RequestMapping註解可以修飾方法，還可以修飾類。 當同時修飾類和方法時，請求的url就 ...
  • java基礎（六）：面向對象
    面向對象 面向對象：以類的方式組織代碼，以對象組織數據 特性： 封裝 繼承 多態 類：抽象概念 對象：具體事物 面向對象是java學習的重中之重，畢竟java就是一個面向對象的語言~ 類 = 屬性+方法 面向對象的概念適合複雜系統、多人協作 從巨集觀上來說，java是面向對象的，但在微觀上是面向過程的 ...
  • RabbitMQ的使用介紹
    一、RabbitMQ是什麼 RabbitMQ是一種常用的消息中間件，是基於AMQP協議，採用erlang語言開發的面向消息服務的中間件，是一個獨立的系統應用程式，可以管理伺服器計算資源和網路通信。一般可作為同構或異構系統間的數據交換平臺，由於erlang語言的高併發特性，使得RabbitMQ的性能較 ...
  • 跟著廖雪峰學python 003
    ​ ​編輯 列表和元組 list 是一種有序、可變的數據類型，可添加刪除其中的元素。 len()函數：可以獲取列表元素的個數 classmates = ['Micheal' , 'Bob' , 'James'] print(classmates) print(len(classmates)) Ter ...
  • 記一次selenium爬取p站圖片的經歷
    突發奇想,爬取p站圖片做個壁紙圖庫(bukemiaoshu),當然這裡有許多的門檻,但是為了實現理想,暫時沒想那麼多了,直接開乾(不是專業做測試和自動化的,如有大佬請評論指教!!!) 1.進入登錄頁由於p站是需要登錄的,聽說p站反爬,requests應該不是那麼好使,於是使用selenium模擬人工 ...
  • 《分散式技術原理與演算法解析》學習筆記Day02
    這篇文章主要描述分散式系統的發展歷程和分散式系統的衡量指標。發展歷程包括了單機模式、數據並行模式和任務並行模式。分散式系統的衡量指標包括性能、資源占用、可用性和可擴展性。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類