Apa perbedaan antara <? extends Base> dan <T extends Base>?

Dalam contoh ini:

import java.util.*;

public class Example {
    static void doesntCompile(Map<Integer, List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    static void function(List<? extends Number> outer)
    {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

doesntCompile() gagal dikompilasi dengan:

Example.java:9: error: incompatible types: HashMap<Integer,List<Integer>> cannot be converted to Map<Integer,List<? extends Number>>
        doesntCompile(new HashMap<Integer, List<Integer>>());
                      ^

sementara compiles()diterima oleh kompiler.

Jawaban ini menjelaskan bahwa satu-satunya perbedaan adalah tidak seperti itu <? ...>, <T ...>memungkinkan Anda merujuk jenisnya nanti, yang tampaknya tidak menjadi masalah.

Apa perbedaan antara <? extends Number>dan <T extends Number>dalam kasus ini dan mengapa tidak dikompilasi pertama?

Dengan mendefinisikan metode dengan tanda tangan berikut:

static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

dan memohon seperti:

compiles(new HashMap<Integer, List<Integer>>());

Dalam jls §8.1.2 kita temukan, itu (bagian yang menarik dicetak tebal oleh saya):

Deklarasi kelas generik mendefinisikan sekumpulan tipe parameter (§4.5), satu untuk setiap kemungkinan doa bagian parameter tipe berdasarkan argumen tipe . Semua tipe parameter ini berbagi kelas yang sama pada saat run time.

Dengan kata lain, tipe Tini cocok dengan tipe input dan ditetapkan Integer. Tanda tangan akan efektif menjadi static void compiles(Map<Integer, List<Integer>> map).

Ketika sampai pada doesntCompilemetode, jls mendefinisikan aturan subtyping ( §4.5.1 , dicetak tebal oleh saya):

Argumen tipe T1 dikatakan mengandung argumen tipe T2 lain, ditulis T2 <= T1, jika himpunan tipe yang dilambangkan dengan T2 terbukti merupakan himpunan bagian dari himpunan tipe yang ditunjukkan oleh T1 di bawah penutupan reflektif dan transitif dari aturan berikut ( di mana <: menunjukkan subtyping (§4.10)):

• ? memperpanjang T <=? memanjang S jika T <: S

• ? memperpanjang T <=?

• ? super T <=? super S jika S <: T

• ? super T <=?

• ? super T <=? memperpanjang Object

• T <= T

• T <=? memanjang T

• T <=? super T

Ini berarti, yang ? extends Numbermemang mengandung Integeratau bahkan List<? extends Number>mengandung List<Integer>, tetapi tidak demikian halnya dengan Map<Integer, List<? extends Number>>dan Map<Integer, List<Integer>>. Lebih lanjut tentang topik itu dapat ditemukan di utas SO ini . Anda masih bisa membuat versi dengan ?wildcard berfungsi dengan mendeklarasikan, bahwa Anda mengharapkan subtipe dari List<? extends Number>:

public class Example {
    // now it compiles
    static void doesntCompile(Map<Integer, ? extends List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    public static void main(String[] args) {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

Dalam panggilan:

compiles(new HashMap<Integer, List<Integer>>());

T cocok dengan Integer, jadi jenis argumennya adalah a Map<Integer,List<Integer>>. Ini bukan kasus untuk metode doesntCompile: jenis argumen tetap Map<Integer, List<? extends Number>>apa pun argumen aktual dalam panggilan; dan itu tidak dapat ditugaskan dari HashMap<Integer, List<Integer>>.

MEMPERBARUI

Dalam doesntCompilemetode ini, tidak ada yang mencegah Anda melakukan hal seperti ini:

static void doesntCompile(Map<Integer, List<? extends Number>> map) {
    map.put(1, new ArrayList<Double>());
}

Jadi jelas, itu tidak dapat menerima HashMap<Integer, List<Integer>>argumen.

Contoh demonstrasi yang disederhanakan. Contoh yang sama dapat divisualisasikan seperti di bawah ini.

static void demo(List<Pair<? extends Number>> lst) {} // doesn't work
static void demo(List<? extends Pair<? extends Number>> lst) {} // works
demo(new ArrayList<Pair<Integer>()); // works
demo(new ArrayList<SubPair<Integer>()); // works for subtype too

public static class Pair<T> {}
public static class SubPair<T> extends Pair<T> {}

List<Pair<? extends Number>>adalah tipe wildcard multi-level sedangkan List<? extends Number>tipe wildcard standar.

Instansiasi konkret yang valid dari tipe wild card List<? extends Number>termasuk Numberdan setiap subtipe dari Numbersedangkan dalam kasus List<Pair<? extends Number>>yang merupakan argumen tipe dari argumen tipe dan itu sendiri memiliki instantiasi konkret dari tipe generik.

Generik tidak tetap sehingga Pair<? extends Number>tipe wild card hanya dapat menerima Pair<? extends Number>>. Tipe dalam ? extends Numbersudah kovarian. Anda harus menjadikan tipe penutup sebagai kovarian untuk memungkinkan kovarian.

Saya akan merekomendasikan Anda untuk melihat dokumentasi wildcard generik terutama panduan untuk penggunaan wildcard

Terus terang metode Anda #doesntCompile

static void doesntCompile(Map<Integer, List<? extends Number>> map) {}

dan panggilan seperti

doesntCompile(new HashMap<Integer, List<Integer>>());

Secara fundamental tidak benar

Mari tambahkan implementasi hukum :

    static void doesntCompile(Map<Integer, List<? extends Number>> map) {
        List<Double> list = new ArrayList<>();
        list.add(0.);
        map.put(0, list);
    }

Ini benar-benar baik, karena Double meluas Angka, jadi put List<Double>juga benar-benar baik List<Integer>, kan?

Namun, apakah Anda masih menganggap itu legal untuk lulus new HashMap<Integer, List<Integer>>()dari contoh Anda di sini ?

Compiler tidak berpikir begitu, dan melakukan yang terbaik untuk menghindari situasi seperti itu.

Cobalah untuk melakukan implementasi yang sama dengan metode #compile dan kompiler jelas tidak akan memungkinkan Anda untuk memasukkan daftar ganda ke dalam peta.

    static <T extends Number> void compiles(Map<Integer, List<T>> map) {
        List<Double> list = new ArrayList<>();
        list.add(10.);
        map.put(10, list); // does not compile
    }

Pada dasarnya Anda dapat menempatkan apa-apa kecuali List<T>bahwa ini mengapa itu aman untuk memanggil metode yang dengan new HashMap<Integer, List<Integer>>()atau new HashMap<Integer, List<Double>>()atau new HashMap<Integer, List<Long>>()atau new HashMap<Integer, List<Number>>().

Jadi singkatnya, Anda mencoba menipu dengan kompiler dan itu cukup bertahan melawan kecurangan tersebut.

NB: jawaban yang diposting oleh Maurice Perry benar sekali. Saya hanya tidak yakin itu cukup jelas, jadi saya mencoba (sangat berharap saya berhasil) untuk menambahkan posting yang lebih luas.