Java泛型中的PECS原則是什么

本篇內容介紹了“Java泛型中的PECS原則是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

先來看一個錯誤：

List<? extends Foo> list1 = new ArrayList<Foo>();
List<? extends Foo> list2 = new ArrayList<Foo>();

 /* Won't compile */
 list2.add( new Foo() ); //error 1
 list1.addAll(list2);    //error 2

error 1:

IntelliJ says:

add(capture<? extends Foo>) in List cannot be applied to add(Foo)

The compiler says:

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>

error 2:

IntelliJ gives me

addAll(java.util.Collection<? extends capture<? extends Foo>>) in List 
cannot be applied to addAll(java.util.List<capture<? extends Foo>>)

Whereas the compiler just says

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>
        list1.addAll(list2);

上面原因出現分析如下：

泛型不是協變的

在 Java 語言中，數組是協變的，也就是說，如果 Integer 擴展了 Number，那么不僅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求 Number[] 的地方完全可以傳遞或者賦予 Integer[]。（更正式地說，如果 Number是 Integer 的超類型，那么 Number[] 也是 Integer[]的超類型）。但是在泛型類型中 List< Number> 不是 List< Integer> 的超類型，也就是說在需要 List< Number> 的地方不能傳遞 List< Integer>。為啥呢？如果不這么做，將破壞要提供的類型安全泛型。

泛型是為了在編譯期，檢查參數類型的是否正確。如果子類賦值給超類，將破壞了類型安全

對于數組來說，String[] 是可以賦值給Object[]：

public class Test {
    public static void main(String[] args) {
        String[] strArray = new String[3];
        Object[] objArray = strArray;
    }
}

集合這么寫就會有編譯錯誤：

public class Test {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        // 編譯 Error:(14, 32) java: 不兼容的類型: java.util.List<java.lang.String>無法轉換為java.util.List<java.lang.Object>
        List<Object> objList = strList; 
    }
}

PECS法則

在泛型不是協變中提到，在使用 List< Number> 的地方不能傳遞 List< Integer>，那么有沒有辦法能讓他兩兼容使用呢？答案是：有，可以使用通配符。

主要是 extends 和 super 關鍵字。比如：

HashMap< T extends String>;
HashMap< ? extends String>;
HashMap< T super String>;
HashMap< ? super String>;

主要涉及的是Java泛型中重要的PECS法則：

? extends T

類型的上界是 T，參數化類型可能是 T 或 T 的子類：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? extends Fruit> fruits = new ArrayList<>();
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile error
        fruits.add(new Apple());    // compile error
        //  以上是因為 fruits 的上線是fruit 可以指向各種子類型水果，你添加的可能跟他指向不同！

        fruits = new ArrayList<Fruit>(); // compile success  Java中的多態
        fruits = new ArrayList<Apple>(); // compile success Java中的多態
        fruits = new ArrayList<Food>(); // compile error  太超前了
        fruits = new ArrayList<? extends Fruit>(); // compile error: 通配符類型無法實例化  Java 強制規定 

        Fruit object = fruits.get(0);    // compile success
    }
}

存入數據：

• 賦值是參數化類型為 Fruit 的集合和其子類的集合都可以成功  用的是Java中的多態，Java規定通配符類型無法實例化 比如 new ArrayList<? extends Fruit>()。

• 編譯器會阻止將Strawberry(草莓)類加入fruits。在向fruits中添加元素時，編譯器會檢查類型是否符合要求。因為編譯器只知道fruits是Fruit某個子類的List，但并不知道這個子類具體是什么類，為了類型安全，只好阻止向其中加入任何子類。

• 那么可不可以加入Fruit呢？很遺憾，也不可以。事實上，不能往使用了? extends的數據結構里寫入任何的值。

讀取數據

但是，由于編譯器知道它總是Fruit的子類型，因此我們總可以從中讀取出Fruit對象：

Fruit fruit = fruits.get(0);

? super T

表示類型的下界是 T，參數化類型可以是 T 或 T 的超類：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? super Fruit> fruits = new ArrayList<>();// 表示 一定是大于等于Fruit 類 
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile success //  多態的添加
        fruits.add(new Apple());    // compile success

        fruits = new ArrayList<Fruit>(); // compile success
        fruits = new ArrayList<Apple>(); // compile error 
        fruits = new ArrayList<Food>(); // compile success
        fruits = new ArrayList<? super Fruit>(); // compile error: 通配符類型無法實例化      

        Fruit object = fruits.get(0); // compile error
    }
}

存入數據：

• super 通配符類型同樣不能實例化 new ArrayList<? super Fruit>() ，Fruit 和其超類的集合均可賦值

• 這里 add 時 Fruit 及其子類均可成功，為啥呢？因為已知 fruits 的參數化類型必定是 Fruit 或其超類 T，那么 Fruit 及其子類肯定可以賦值給 T。

• 出于對類型安全的考慮，我們可以加入Apple對象或者其任何子類（如RedApple）對象（因為編譯器會自動向上轉型），但由于編譯器并不知道List的內容究竟是Apple的哪個超類，因此不允許加入特定的任何超類型。

• 因為你傳入的可能是各種超類，所以 在get的時候是無法確定變量類型的，因此無法get 。只能用Object 基類

讀取數據

Object fruit = apples.get(0);

PECS原則總結

從上述兩方面的分析，總結PECS原則如下：

1. 如果要從集合中讀取類型T的數據，并且不能寫入，可以使用 ? extends 通配符；(Producer Extends)

2. 如果要從集合中寫入類型T的數據，并且不能讀取，可以使用 ? super 通配符；(Consumer Super)

3. 如果既要存又要取，那么就不要使用任何通配符，但是可以同時使用 extends 跟 super。

4. 以“?”聲明的集合，不能往此集合中添加元素，所以它只能作為生產者(亦即它只能被迭代)

5. Java強制在創建對象的時候必須給類型參數制定具體的類型，不能使用通配符，也就是說new ArrayList<? extends A>()，new ArrayList<?>()這種形式的初始化語句是不允許的。

現在再去思考最開始的問題，應該會更清楚一點

“Java泛型中的PECS原則是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！