2. 程式人生 > 其它 >Java泛型學習筆記

Java泛型學習筆記

阿新 • • 發佈：2020-12-08

技術標籤：Java學習

泛型

泛型是一種“程式碼模板”，可以用一套程式碼套用各種型別。

什麼是泛型

在講解什麼是泛型之前，我們先觀察Java標準庫提供的ArrayList，它可以看作“可變長度”的陣列，因為用起來比陣列更方便。

實際上ArrayList內部就是一個Object[] 陣列,配合儲存一個當前分配的長度，就可以充當“可變陣列”：

public class ArrayList {
    private Object[] array;
    private int size;
    
    public void add(Object e){
        
    }
 

    
    public void remove(int index){
        
    }
    
    public Object get(int index){
        return null;
    }
}

如果用上述ArrayList儲存String型別，需要強制轉型。

ArrayList list = new ArrayList();
list.add("Hello");
String first = (String) list.get(0);
System.out.println(first);

很容易出現ClassCastException,因為容易"誤轉型":

list.add(123);
//error: ClassCastException
String second = (String) list.get(1);

為String單獨編寫ArrayList是一種解決方法。
實際上，還需要為其他所有的class單獨編寫一種ArrayList：
這是不可能的。

為了解決新的問題，我們必須把ArrayList變成一種模板：ArrayList，T可以是任何class。這樣一來，我們就實現了：編寫一次模板，可以建立任意型別的ArrayList：

ArrayList<String> strList = new ArrayList<String>
 
();
ArratList<Float> floatList = new ArrayList<Float>();
ArrayList<Person> personList = new ArrayList<Person>();

因此，泛型就是定義一種模板，例如ArrayList，然後在程式碼中為用到的類建立對應的ArrayList<型別>:

ArrayList<String> strList = new ArrayList<String>();

由編譯器針對型別作檢查：

strList.add("Hello");//OK
String s = strList.get(0);//OK
strList.add(123);//compile error!
int n = strList.get(0);//compile error!

這樣一來,既實現了編寫一次,萬能匹配,又通過編譯器保證了型別安全:這就是泛型。

向上轉型

在Java標準庫中的ArrayList實現了List介面,它可以向上轉型為LIst:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

List<String> list = new ArrayList<String>();

即型別ArrayList可以向上轉型為List。

要特別注意：不能把ArrayList向上轉型為ArrayList或List。

error:

java: 不相容的型別: java.util.ArrayList<java.lang.Integer>無法轉換為java.util.ArrayList<java.lang.Number>

這是為什麼呢？

因為ArrayList改為ArrayList後,將可以被賦予Float,Double等是Number的子類,但不是Integer的物件,從ArrayList獲取Integer時有可能讀到非Integer物件,產生ClassCastException。

實際上,編譯器為了避免這種錯誤,根本不允許大ArrayList轉型為ArrayList。

ArrayList和ArrayList兩者完全沒有繼承關係。

使用泛型

使用ArrayList時，如果不定義泛型型別時，泛型型別實際上就是Object：

List list = new ArrayList();
list.add("Hello");
list.add("World");
list.add(123);
String first = (String) list.get(0);
String second = (String) list.get(1);
int third = (Integer)list.get(2);

此時,只能把當做Object使用,沒有發揮泛型的優勢。
當我們定義泛型型別後,List的泛型介面變為強型別List:

List<String> list1 = new ArrayList<>();//可以省略後面的String,編譯器可以自動推斷泛型型別。
list1.add("Hello");
list1.add("World");
String s1 = list1.get(0);
String s2 = list1.get(1);

泛型介面

除了ArrayList使用了泛型,還可以在介面中使用泛型.例如,Arrays.sort(Object[])可以對任意陣列進行排序,但待排序的元素必須實現Comparable這個泛型介面:

public interface Comparable<T> {
	/**
	* 返回負數:當前例項比引數o小
	* 返回0: 當前例項與引數o相等
	* 返回正數: 當前例項比引數o大
	*/
    public int compareTo(T o);
}

編寫泛型

編寫泛型類比普通類要複雜.通常來說,泛型類一般用在集合類中,例如ArrayList,我們很少需要編寫泛型類.

靜態方法

編寫泛型類時,要特別注意,泛型型別不能用於靜態方法.例如:

class Pair<T>{
    private T first;
    private T last;

    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }

    public T getLast() {
        return last;
    }

    public static Pair<T> create(T first,T last){
        return new Pair<T>(first, last);
    }
}

上述程式碼會導致編譯錯誤,我們無法在靜態方法create()的方法引數和返回型別上使用泛型型別T.

對於靜態方法,我們可以單獨改寫為"泛型"方法,只需要使用另一個型別即可.

class Pair<T>{
    private T first;
    private T last;

    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }

    public T getLast() {
        return last;
    }
    
    //靜態泛型方法應該使用其他型別區分:
    public static <K> Pair<K> create(K first,K last){
        return new Pair<K>(first, last);
    }
}

這樣才能清楚地將靜態方法的泛型型別和例項型別的泛型型別區分開.

多個泛型型別

Java標準庫的Map<K,V>就是使用兩種泛型型別的例子.它對key使用一種型別,對Value使用另一種型別.

擦拭法

Java語言的泛型實現方式是擦拭法(Type Erasure).
所謂擦除法是指,虛擬機器對泛型一無所知,所有的工作都是編譯器做的.

Java使用擦拭法實現泛型,導致了:

  • 編譯器把型別視為Obejct;
  • 編譯器根據實現安全的強制轉型.

編譯器看到的程式碼

Pair<String> p = new Pair<>("Hello","World");
String first = p.getFirst();
String last = p.getLast();

而虛擬機器的程式碼並沒有泛型:

Pair p = new Pair("Hello","World");
String first = (String) p.getFirst();
String last = (String) p.getLast();

瞭解了Java泛型的實現方式,我們就知道了Java泛型的侷限:

  1. 不能是基本型別,因為實際型別是Object,Object型別無法持有基本型別;
  2. 無法取得帶泛型的Class,觀察一下程式碼:
public class TypeErasure {

    public static void main(String[] args) {
        Pair2<String> p1 = new Pair2<>("Hello","World");
        Pair2<Integer> p2 = new Pair2<>(123,456);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        System.out.println(c1==c2);
        System.out.println(c1==Pair2.class);
    }

    

}

class Pair2<T>{
    private T first;
    private T last;

    public Pair2(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getLast() {
        return last;
    }

    public void setLast(T last) {
        this.last = last;
    }
}

因為T是Object,我們對Pair<String>和Pair<Integer>型別獲取Class時,獲取到的是同一個Class,也就是Pair類的Class.
  1. 無法判斷帶泛型的型別:
    只有唯一的Pair.class
  2. 不能例項化T型別
    因為T是Object,任何new T()都相當於new Object();沒有意義,禁止.
    要例項化T型別,我們必須藉助額外的Class引數:
    public Pair2(Class<T> clazz) throws IllegalAccessException, InstantiationException {
    first = clazz.newInstance();
    last = clazz.newInstance();
}
    上述程式碼藉助Class引數並通過反射來例項化T型別,使用的時候,也必須傳入Class.
Pair<String> pair = new Pair<>(String.class);

不恰當的覆寫方法

看似正確定義的方法無法編譯
equals(T t)方法實際上會被擦拭成equals(Object t),而這個方法是繼承自Object的,編譯器會阻止一個實際上會變為覆寫的泛型方法定義.

換個方法名,避開與Object的方法同名就可以.
在這裡插入圖片描述

泛型繼承

一個類可以繼承自一個泛型類.
在這裡插入圖片描述
使用的時候,因為子類IntPair並沒有泛型型別,正常使用即可.
在這裡插入圖片描述
前面講了,我們無法獲取Pair的T型別,即給定一個變數Pair p,無法從p中獲取到Integer型別.

但是,在父類是泛型型別的情況下,編譯器就必須把型別T儲存到子類的class檔案中,不然編譯器就不知道IntPair只能存取Integer這種型別.

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class TypeErasure {

    public static void main(String[] args) {
        Class<IntPair> clazz = IntPair.class;
        Type t = clazz.getGenericSuperclass();
        if(t instanceof ParameterizedType){
            ParameterizedType pt = (ParameterizedType) t;
            Type[] types = pt.getActualTypeArguments();//可能有多個泛型型別
            Type firstType = types[0];
            Class<?> typeClass = (Class<?>) firstType;
            System.out.println(typeClass);
        }
    }
}

class Pair2<T>{
    private T first;
    private T last;

    public Pair2(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public Pair2(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }

    public boolean same(T t){
        return this == t;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getLast() {
        return last;
    }

    public void setLast(T last) {
        this.last = last;
    }
}

class IntPair extends Pair2<Integer>{

    public IntPair(Integer first, Integer last) {
        super(first, last);
    }

    public IntPair(Class<Integer> clazz) throws IllegalAccessException, InstantiationException {
        super(clazz);
    }
}

因為Java引入了泛型,所以,只用Class來標記型別已經不夠了.Java的型別系統結構如下:

在這裡插入圖片描述

extends萬用字元

相關推薦

Java泛型學習筆記

技術標籤：Java學習 泛型 泛型是一種“程式碼模板”，可以用一套程式碼套用各種型別。

java 泛型學習隨筆

對於java 泛型 編譯時處理,執行時擦除的特點理解 對於編譯時處理 在使用泛型相關的類或方法時,如果宣告時的型別和具體使用時的型別不一致則直接會編譯不通過

Java泛型學習---第二篇

泛型學習第一篇 1.泛型之擦拭法 泛型是一種類似”模板程式碼“的技術，不同語言的泛型實現方式不一定相同。

Java泛型學習

1、泛型的概念     泛型即“引數化型別”，就比如我們定義方法的時候，定義一個變數，稱為形參，變數值根據傳進去的實參的值不同而改變。而泛型的出現，就是為了解決型別也能根據傳進去的型別改變的問題，所以稱為

淺談三分鐘學習Java泛型中T、E、K、V、？的含義

泛型是Java中一個非常重要的內容，對於Java進階學習是必須要掌握的知識點之所以說這個知識點重要，如果你有過閱讀過一些開源框架的程式碼，那你一定會看到原始碼中有很多地方使用到了泛型。

Java隨筆-Java泛型的一點學習

Java泛型 Java泛型（generics）是JDK 5中引入的一個新特性，允許在定義類和介面的時候使用型別引數（type parameter）。宣告的型別引數在使用時用具體的型別來替換。泛型最主要的應用是在JDK 5中的新集合類框架中。泛

關於泛型學習的學習筆記

技術標籤：java泛型 該筆記在B站黑馬程式設計師 JavaSE強化泛型 課程所記錄 泛型

關於JAVA泛型那點事

相逢便是緣，路過點個贊 ^.^ 概述 Java 泛型（generics）是 JDK 5 中引入的一個新特性,在面向物件程式設計及各種設計模式中有非常廣泛的應用。泛型提供了編譯時型別安全檢測機制，該機制允許程式設計師在編譯時

聊一聊-JAVA 泛型中的萬用字元 T，E，K，V，？

前言 Java 泛型（generics）是 JDK 5 中引入的一個新特性,泛型提供了編譯時型別安全檢測機制，該機制允許開發者在編譯時檢測到非法的型別。

java 泛型全解 - 絕對最詳細

背景 對於java的泛型我一直屬於一知半解的，平常真心用的不多。直到閱讀《Effect Java》,看到很多平常不瞭解的用法，才下定決心，需要系統的學習，並且記錄下來。

細說Java 泛型

為了讓集合容器記住元素型別是jdk1.5引入泛型（Generic Types）的一個主要原因。

java泛型常用萬用字元例項解析

這篇文章主要介紹了java泛型常用萬用字元例項解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java泛型初學者之上、下界萬用字元的深入理解

泛型的由來 為什麼需要泛型 Java的資料型別一般都是在定義時就需要確定，這種強制的好處就是型別安全，不會出現像弄一個ClassCastException的資料給jvm，資料安全那麼執行的class就會很穩定。但是假如說我不知道這

JAVA泛型的繼承和實現、擦除原理解析

這篇文章主要介紹了JAVA泛型的繼承和實現、擦除原理解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java泛型的用法及T.class的獲取過程解析

這篇文章主要介紹了Java泛型的用法及T.class的獲取過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java泛型變數如何新增約束

有時，類或方法需要對型別變數加以約束。下面是一個典型的例子，我們要尋找陣列中的最小元素：

Java泛型機制必要性及原理解析

泛型程式設計（Generic Programming） “使用泛型機制編寫的程式程式碼要比那些雜亂地使用Object變數，然後再進行強制型別轉換的程式碼具有更好的安全性和可讀性。泛型對於集合類尤其有用。”

解析Java 泛型什麼情況下不能使用

一、前言 Java泛型來保證型別安全，防止在執行時發生型別轉換異常，讓型別引數化，提高了程式碼的可讀性和重用率。但是有些情況下泛型也是不允許使用的，以下是不能使用泛型的一些場景。

深入瞭解JAVA泛型

什麼是泛型 泛型的概念：Java泛型（generics）是JDK1.5中引入的一個新特性，泛型提供了編譯時的型別安全監測機制，該機制允許我們在編譯時檢測到非法的型別資料結構。

Java泛型<T> T與T的用法

泛型（Generic type 或者 generics）是對 Java 語言的型別系統的一種擴充套件，以支援建立可以按型別進行引數化的類。可以把型別引數看作是使用引數化型別時指定的型別的一個佔位符，就像方法的形式引數是執行時傳遞