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

Sea發表於2023-02-05

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 ,MapList<?> 可以理解為是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. 最後:

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

在這裡插入圖片描述

相關文章