泛型是什么

Java中的泛型是一種能夠讓用戶在撰寫代碼時避免使用明確的型別而進行型別引數化的機制，Java中的泛型可以讓編程者在代碼撰寫時不必關心具體型別，只用關心型別之間的關系和相互轉換，從而在撰寫代碼的程序中實作型別的復用，這使得代碼更加簡潔、可讀性更高，并且可以提高代碼的可維護性和可擴展性，

Java泛型可以在類、方法、介面、以及陣列等多個地方使用，并且可以結合約束條件來限制型別引數的型別，例如，在定義一個泛型類時，可以使用<T>定義一個泛型型別引數，T可以代表任何具體型別，例如Integer、String、Map等，在使用泛型時，可以將具體型別傳遞給型別引數，然后在方法或者類中使用該型別引數，從而實作代碼的型別自動化，

Java中的泛型還具有型別檢查和型別擦除的特性，型別檢查可以檢查在編譯時期是否使用了正確的型別，避免了在運行時期由于型別轉換錯誤而產生的例外，而型別擦除則是Java泛型在實作時使用的一種技術，它會去掉泛型中的型別引數資訊，并將其變為原始型別，在運行時也不會保留泛型的資訊，從而實作Java泛型的運行時兼容性，

什么是型別引數？

Java中的型別引數是用于泛型編程的占位符，可以用來表示任何型別，它們用尖括號 "<>" 括起來，放置在類名或方法名后面，用來指定通用型別，例如，以下代碼中的 T 就是一個型別引數：

public class MyClass<T> {
    private T value;
    
    public void setValue(T value) {
        this.value = https://www.cnblogs.com/yyyyfly1/archive/2023/06/11/value;
    }
    
    public T getValue() {
        return value;
    }
}

在上面的代碼中，T 代表一個通用型別，可以在創建 MyClass 物件時指定 T 的具體型別，如：

MyClass<Integer> intObj = new MyClass<>();
MyClass<String> strObj = new MyClass<>();

這樣，intObj 物件中的 value 的型別就是 Integer，strObj 物件中的 value 的型別就是 String，型別引數可以用在類、方法、介面等地方，用來實作通用的演算法，使用型別引數可以允許我們撰寫一次通用的代碼，可以用于不同型別的資料，是 Java 泛型編程的核心特性，

什么是型別擦除？

型別擦除（type erasure）是指在Java編譯期間，對泛型型別引數資訊的擦除，將所有泛型型別引數都用它們的上界（或Object型別）替換，從而在運行時不會保留泛型型別資訊，具體來說，編譯器會將泛型類、泛型介面中的型別引數用對應的型別上限（即extends關鍵字后面的型別）替換，泛型方法中的型別引數也會被替換，例如，對于以下泛型類：

public class Pair<T, S> {
    private T first;
    private S second;


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


    public T getFirst() {
        return first;
    }


    public S getSecond() {
        return second;
    }
}

它在編譯后會被轉換為：

public class Pair {
    private Object first;
    private Object second;


    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }


    public Object getFirst() {
        return first;
    }


    public Object getSecond() {
        return second;
    }
}

這就是型別擦除的程序，所有泛型型別資訊都被擦除并替換為Object型別，雖然泛型型別資訊被擦除，但在運行時可以通過反射機制獲取到泛型型別資訊，這使得泛型在運行時仍然可以使用，但是，由于型別擦除，泛型型別引數在運行時無法進行型別檢查，因此可能會導致型別安全問題，

什么是通配符型別？

Java中的通配符型別是一種泛型型別，用于表示未知型別的泛型引數，通配符型別由問號（？）表示，其可以用作方法的引數型別、欄位型別、區域變數型別等任何地方需要使用泛型型別的地方，

通配符型別有兩種形式：無界通配符型別和有界通配符型別，

無界通配符型別是指使用符號 ? 表示未知型別，例如 List<?>，在使用無界通配符型別時，不能添加任何元素到集合中，因為這個集合的元素型別是未知的，但是，可以從集合中獲取元素，并將其轉換為 Object 型別，

有界通配符型別是指使用符號 ? extends 或 ? super，限制泛型引數的型別范圍，例如，List<? extends Number> 表示泛型引數必須是 Number 型別或其子型別，而 List<? super Integer> 表示泛型引數必須是 Integer 型別或其父型別，在使用有界通配符型別時，可以添加元素到集合中，并能獲取它們，

注意，通配符型別不能用于泛型類或泛型介面的定義，只能作為方法引數或回傳型別的通用形式使用，

什么是泛型方法和泛型類

泛型方法和泛型類是Java中重要的概念，它們的作用是為了提高代碼的可重用性和安全性，

泛型方法是在方法的宣告中使用泛型型別，使得方法可以接受不同型別的引數，同時還可以指定回傳值或方法體中使用的泛型型別，泛型方法通常有以下特點：

泛型方法可以在方法中定義自己的型別引數，也可以使用類定義的型別引數，
泛型方法可以接受任意型別的引數，即可以接受引數化型別，也可以接受普通型別，
泛型方法可以有多個型別引數，也可以沒有型別引數，
泛型方法可以有泛型型別的回傳值，

下面是一個使用泛型方法的例子：

public static <T> void printArray(T[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

在這個例子中，我們定義了一個名為 printArray 的泛型方法，它接受一個泛型陣列作為引數，并且使用 for 回圈遍歷陣列的每個元素，最后輸出所有元素到控制臺，

泛型類是在類的宣告中使用泛型型別，使得類可以接受不同型別的引數，同時還可以指定類中使用的泛型型別，泛型類通常有以下特點：

泛型類可以在類名后面添加泛型型別引數，
泛型類可以在類中定義泛型型別的實體變數，
泛型類可以有泛型型別的構造方法，
泛型類可以有泛型型別的方法，

下面是一個使用泛型類的例子：

public class Box<T> {
    private T value;

    public Box(T value) {
        this.value = https://www.cnblogs.com/yyyyfly1/archive/2023/06/11/value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public static void main(String[] args) {
        Box box = new Box<>(10);
        System.out.println(box.getValue());
    }
}

在這個例子中，我們定義了一個名為 Box 的泛型類，它有一個泛型型別引數 T，同時定義了一個名為 value 的實體變數，以及相應的 get 和 set 方法，在 main 方法中，我們創建了一個 Box 物件，并且使用泛型型別為 Integer 的引數，然后輸出了這個物件的值到控制臺，

總的來說，泛型方法和泛型類是Java中非常重要的概念，它們可以為我們提供更加靈活和安全的編程方式，同時也是提高代碼可讀性和可維護性的有效手段，

泛型類中是否可以繼承泛型類

Java中泛型類可以繼承泛型類，這一特性被稱為泛型的繼承或泛型的子類化，

在泛型類繼承中，子類繼承的父類可以是泛型類也可以是非泛型類，當子類繼承的父類是泛型類時，子類可以繼承父類的泛型型別；也可以在繼承時指定自己的泛型型別，

下面是一個范例來展示Java中泛型類繼承泛型類的用法：

public class Parent<T> {
    // 泛型型別 T
    private T data;

    public void setData(T data) {
        this.data = https://www.cnblogs.com/yyyyfly1/archive/2023/06/11/data;
    }

    public T getData() {
        return data;
    }
}

public class Child extends Parent {
    // 繼承泛型類 Parent
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child(); // 子類指定了泛型型別為 String
        child.setData("Hello World");
        System.out.println(child.getData()); // 輸出結果為 "Hello World"
    }
}

在上面的例子中，Child類繼承了Parent類，由于Parent類是一個泛型類，所以Child類又繼承了Parent類的泛型型別T，而在定義Child類時，也可以在繼承Parent類時指定T的具體型別，如Child<String>，從而使Child類也成為具有泛型特性的類，

總結一下，Java中允許泛型類繼承泛型類，子類也可以使用父類的泛型型別或為自己指定泛型型別，這個特性可以幫助開發者更好地管理和組織泛型類，能夠提升代碼的可重用性和可讀性，

泛型方法中是否可以宣告泛型類

Java中泛型方法可以宣告泛型類，這樣可以在方法中使用泛型型別引數，從而在方法中實作通用的操作，

除了宣告泛型類，泛型方法還可以宣告泛型方法引數、回傳型別，以及利用泛型通配符進行型別轉換等常用操作，

以下是一個簡單的示例，展示了在泛型方法中宣告泛型類的用法：

public class MyClass<T> {
    public <E> void printElements(E[] elements) {
        for (E element : elements) {
            System.out.println(element.toString());
        }
        T obj = new T();  // 泛型型別別引數T在泛型方法中使用
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"Hello", "World"};

        MyClass<Integer> myClass = new MyClass<>();
        myClass.printElements(integers);

        MyClass<String> myClass1 = new MyClass<>();
        myClass1.printElements(strings);
    }
}

在上述代碼中，我們定義了一個泛型類 MyClass<T>，其中，又定義了一個名為 printElements 的泛型方法，該方法中使用了泛型型別引數 E[]，并在方法中對陣列元素進行遍歷輸出；同時，方法中也使用了泛型型別引數 T，在方法中初始化一個泛型型別別引數T的物件，

在Test類中，我們實體化了兩個 MyClass 類，分別強制指定泛型型別引數為 Integer 型別和 String 型別，并通過執行各自的 printElements 方法來列印陣列元素，

通過這種方式，Java中的泛型方法不僅支持泛型型別引數，也支持對泛型類（包括實體化泛型類物件）的操作，從而讓我們可以實作更加通用的方法封裝，提升代碼的可讀性和復用性，

為什么型別引數不能是原始型別

泛型的型別擦除機制

Java中的泛型是通過型別擦除機制實作的，泛型類和方法會在編譯時通過擦除型別資訊來去除泛型的影響，轉換成原始型別，例如，List<String>和List<Integer>在編譯后都會變成List<Object>，

原始型別與泛型類無法一起使用，這樣會破壞Java 的型別安全，如果型別引數允許原始型別，那么在擦除型別資訊之后，無法在運行時獲得型別資訊，這就導致了無法撰寫通用的泛型代碼，

原始型別的限制

原始型別不能繼承任何類，也無法實作任何介面，如果型別引數可以是原始型別，那么泛型類就無法利用Java強大的面向物件特性來實作更加復雜、靈活的結構，

自動型別轉換問題

Java中自動型別轉換和型別擦除機制可能會導致型別引數變為原始型別，例如，我們在泛型方法中將一個原始型別轉換為一個泛型型別引數，當運行時擦除型別時，這個泛型型別變成了Object型別，而不是我們想要的型別引數，

綜上所述，Java中為什么型別引數不能是原始型別，是因為這種做法會破壞Java的型別安全和面向物件特性，無法實作通用的泛型代碼，

什么是限定通配符和無限定通配符？

限定通配符是Java中泛型的一個重要特性，用于指定泛型引數的上界或下界，

在Java中，泛型引數不僅可以指定具體的型別，還可以指定一個范圍，即可以定義型別的上界或下界，限定通配符就是用來指定這個范圍的符號，

限定通配符分為extends和super兩種型別：

extends限定通配符：用于指定泛型引數的上界，表示型別必須是指定型別或其子類，

示例：List<? extends Number> 表示泛型引數必須是Number或其子類，如Integer、Double等，

super限定通配符：用于指定泛型引數的下界，表示型別必須是指定型別或其父類，

示例：List<? super Integer> 表示泛型引數必須是Integer或其父類，如Number、Object等，

限定通配符的作用是確保泛型引數的型別符合特定的條件，同時增加代碼的可用性和可讀性，

Java中的無限定通配符（Unbounded Wildcard）是指泛型引數沒有任何限制，使用符號"?"來表示，

示例：List<?> 表示List中可以存放任何型別的物件，相當于是List<Object>的簡化寫法，

無限定通配符可以用于以下情況：

當泛型引數型別并不重要時，比如在方法中只需要對泛型引數進行處理而不需要知道具體型別，
當泛型型別的上界或下界無法確定時，比如在方法中需要接受不同型別的List物件，但是這些List物件的元素型別并不確定，

無限定通配符并不能直接呼叫引數的方法或者添加新的元素，因為其具體的型別是未知的，需要通過強制型別轉換才能進行操作，

什么是型別邊界

Java泛型中的型別邊界（Type Bound）是指限制泛型型別引數的范圍，使得引數只能是特定類或其子類，或者實作了特定介面的類或其實作類，

型別邊界有兩種形式：extends和super，extends用于限制型別引數的上界（Upper Bound），即指定引數只能是某一類或其子類的型別；super用于限制型別引數的下界（Lower Bound），即指定引數只能是某一類或其父類的型別，

//型別邊界為Number及其子類


public class GenericClass<T extends Number> {


private T number;


public GenericClass(T number) {


this.number = number;


}


public T getNumber() {


return number;


}


}


GenericClass<Integer> intClass = new GenericClass<>(10);


GenericClass<Double> doubleClass = new GenericClass<>(3.14);


//型別邊界為String及其父類


public class GenericClass<T super String> {


private T str;

public GenericClass(T str) {

	this.str = str;

}

public T getString() {

	return str;

}

}


GenericClass<Object> objClass = new GenericClass<>("Hello World");


GenericClass<CharSequence> charSeqClass = new GenericClass<>("Hello World");

什么是協變

Java泛型中的協變（Covariant）是指泛型型別引數的子型別關系能夠被繼承到泛型類的實體化型別中，也就是說，子型別的泛型類實體可以替代父型別的泛型類實體，

在Java中，協變型別只有在泛型引數是用作方法回傳值型別時才可以生效，在這種情況下，如果泛型實體可以回傳子型別物件，則該型別為協變型別，

public class Animal {}


public class Dog extends Animal {}


//泛型協變


public class GenericClass<T> {


public T getAnimal() {


return null;


}


}


GenericClass<Dog> dogClass = new GenericClass<>();


GenericClass<? extends Animal> animalClass = dogClass;


Animal animal = animalClass.getAnimal(); //協變成Animal型別


Dog dog = dogClass.getAnimal(); //無需轉換，回傳型別為Dog

什么是型別變數的繼承

Java泛型中，型別變數的繼承是指當一個泛型型別引數被宣告在一個類中，并被另一個類繼承時，繼承后的子類可以直接使用該泛型型別引數，

具體來說，當一個類宣告了泛型型別引數T，在另一個類中繼承該類時，可以通過在子類中指定T的具體型別來使用其父類中宣告的泛型型別，子類可以繼承和使用其父類中的泛型型別，或者在實作介面時使用泛型型別，

public class ParentClass<T> {


T t;


public T getT() {


return t;


}


}


public class ChildClass<T> extends ParentClass<T> {


}


ChildClass<String> child = new ChildClass<>();


child.setT("Hello"); //繼承父類中的泛型型別T


String s = child.getT(); //繼承父類中的泛型型別T


//類實作介面時使用泛型型別


public interface MyInterface<T> {


public T getT();


}


public class MyClass<T> implements MyInterface<T> {


}


MyClass<String> myClass = new MyClass<>();


String s = myClass.getT(); //使用泛型型別T

在黑夜里夢想著光，心中覆寫悲傷，在悲傷里忍受孤獨，空守一絲溫暖，我的淚水是無底深海，對你的愛已無言，相信無盡的力量，那是真愛永在，我的信仰是無底深海，澎湃著心中火焰，燃燒無盡的力量，那是忠誠永在，

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

標籤：其他

上一篇：List 介面及其常用方法

下一篇：返回列表

【技識訓累】Java中的泛型【一】