Mengapa array kovarian tetapi obat generik tidak berubah-ubah?

From Java Efektif oleh Joshua Bloch,

1. Array berbeda dari tipe generik dalam dua cara penting. Array pertama adalah kovarian. Obat generik tidak berubah-ubah.

2. Kovarian berarti jika X adalah subtipe Y maka X [] juga akan menjadi sub tipe Y []. Array adalah kovarian Karena string adalah subtipe dari Objek Jadi

   String[] is subtype of Object[]

   Invarian berarti tidak peduli X menjadi subtipe Y atau tidak,

    List<X> will not be subType of List<Y>.

Pertanyaan saya adalah mengapa keputusan untuk membuat array kovarian di Jawa? Ada posting SO lainnya seperti Mengapa Array invarian, tetapi Daftar kovarian? , tetapi mereka tampaknya berfokus pada Scala dan saya tidak dapat mengikuti.

Melalui wikipedia :

Versi awal Java dan C # tidak termasuk obat generik (alias parametrik polimorfisme).

Dalam pengaturan seperti itu, membuat array invarian mengesampingkan program polimorfik yang berguna. Misalnya, pertimbangkan untuk menulis fungsi untuk mengocok array, atau fungsi yang menguji dua array untuk kesetaraan menggunakan Object.equalsmetode pada elemen. Implementasi tidak tergantung pada jenis elemen yang disimpan dalam array, jadi harus dimungkinkan untuk menulis fungsi tunggal yang bekerja pada semua jenis array. Sangat mudah untuk mengimplementasikan fungsi tipe

boolean equalArrays (Object[] a1, Object[] a2);
void shuffleArray(Object[] a);

Namun, jika tipe array diperlakukan sebagai invarian, hanya akan mungkin untuk memanggil fungsi-fungsi ini pada array dengan tipe yang tepat Object[]. Seseorang tidak bisa, misalnya, mengocok array string.

Oleh karena itu, Java dan C # memperlakukan tipe array secara kovarian. Misalnya, dalam C # string[]adalah subtipe dari object[], dan di Jawa String[]adalah subtipe dari Object[].

Ini menjawab pertanyaan "Mengapa array kovarian?", Atau lebih tepatnya, "Mengapa tidak array dibuat kovarian pada waktu itu ?"

Ketika obat generik diperkenalkan, mereka sengaja tidak dibuat kovarian karena alasan yang ditunjukkan dalam jawaban ini oleh Jon Skeet :

Tidak, a List<Dog>bukan a List<Animal>. Pertimbangkan apa yang dapat Anda lakukan dengan List<Animal>- Anda dapat menambahkan hewan apa pun ke dalamnya ... termasuk kucing. Sekarang, bisakah Anda secara logis menambahkan kucing ke sampah anak-anak anjing? Benar-benar tidak.

// Illegal code - because otherwise life would be Bad
List<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs; // Awooga awooga
animals.add(new Cat());
Dog dog = dogs.get(0); // This should be safe, right?

Tiba-tiba Anda memiliki kucing yang sangat bingung.

Motivasi asli untuk membuat array kovarian yang dijelaskan dalam artikel wikipedia tidak berlaku untuk obat generik karena wildcard memungkinkan ekspresi kovarians (dan contravariance) menjadi mungkin, misalnya:

boolean equalLists(List<?> l1, List<?> l2);
void shuffleList(List<?> l);

Alasannya adalah bahwa setiap array tahu tipe elemennya selama runtime, sedangkan koleksi generik tidak karena penghapusan tipe.

Sebagai contoh:

String[] strings = new String[2];
Object[] objects = strings;  // valid, String[] is Object[]
objects[0] = 12; // error, would cause java.lang.ArrayStoreException: java.lang.Integer during runtime

Jika ini diizinkan dengan koleksi umum:

List<String> strings = new ArrayList<String>();
List<Object> objects = strings;  // let's say it is valid
objects.add(12);  // invalid, Integer should not be put into List<String> but there is no information during runtime to catch this

Tetapi ini akan menimbulkan masalah nanti ketika seseorang mencoba mengakses daftar:

String first = strings.get(0); // would cause ClassCastException, trying to assign 12 to String

Mungkin bantuan ini : -

Generik bukan kovarian

Array dalam bahasa Java adalah kovarian - yang berarti bahwa jika Integer memperluas Number (yang memang), maka tidak hanya Integer juga Number, tetapi Integer [] juga a Number[], dan Anda bebas untuk lulus atau menetapkan Integer[]di mana a Number[]dipanggil. (Lebih formal, jika Number adalah supertype dari Integer, maka Number[]adalah supertype dari Integer[].) Anda mungkin berpikir hal yang sama berlaku untuk tipe generik juga - itu List<Number>adalah supertype dari List<Integer>, dan bahwa Anda dapat melewati di List<Integer>mana a List<Number>diharapkan. Sayangnya, tidak berfungsi seperti itu.

Ternyata ada alasan bagus mengapa hal itu tidak bekerja seperti itu: Ini akan memecah tipe keselamatan yang seharusnya disediakan oleh generik. Bayangkan Anda bisa menetapkan a List<Integer>ke List<Number>. Kemudian kode berikut akan memungkinkan Anda untuk memasukkan sesuatu yang bukan bilangan bulat ke dalam List<Integer>:

List<Integer> li = new ArrayList<Integer>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));

Karena ln adalah a List<Number>, menambahkan Float ke tampak legal. Tetapi jika dalam aliased dengan li, maka itu akan melanggar janji keselamatan-jenis yang tersirat dalam definisi li - bahwa itu adalah daftar bilangan bulat, itulah sebabnya tipe generik tidak bisa kovarian.

Array adalah kovarian untuk setidaknya dua alasan:

• Berguna untuk koleksi yang menyimpan informasi yang tidak akan pernah berubah menjadi kovarian. Agar koleksi T menjadi kovarian, toko pendukungnya juga harus kovarian. Sementara orang dapat merancang Tkoleksi abadi yang tidak menggunakan T[]sebagai backing store (mis. Menggunakan pohon atau daftar tertaut), koleksi seperti itu tidak akan berkinerja sebaik koleksi yang didukung oleh array. Orang mungkin berpendapat bahwa cara yang lebih baik untuk menyediakan koleksi yang tidak dapat diubah kovarian adalah dengan mendefinisikan tipe "array tidak berubah yang kovarian" yang bisa mereka gunakan di backing store, tetapi dengan membiarkan array kovarians mungkin lebih mudah.

• Array akan sering dimutasi oleh kode yang tidak tahu apa yang akan ada di dalamnya, tetapi tidak akan memasukkan ke dalam array apa pun yang tidak dibaca dari array yang sama. Contoh utama dari ini adalah kode penyortiran. Secara konseptual, dimungkinkan untuk tipe array untuk memasukkan metode untuk bertukar atau mengubah elemen (metode seperti itu bisa sama-sama berlaku untuk semua tipe array), atau mendefinisikan objek "manipulator array" yang menyimpan referensi ke array dan satu atau lebih hal yang telah dibaca dari itu, dan dapat mencakup metode untuk menyimpan item yang sebelumnya dibaca ke dalam array dari mana mereka datang. Jika array bukan kovarian, kode pengguna tidak akan dapat mendefinisikan tipe seperti itu, tetapi runtime bisa menyertakan beberapa metode khusus.

Fakta bahwa array adalah kovarian dapat dipandang sebagai peretasan yang buruk, tetapi dalam kebanyakan kasus itu memfasilitasi pembuatan kode kerja.

Fitur penting dari tipe parametrik adalah kemampuan untuk menulis algoritma polimorfik, yaitu algoritma yang beroperasi pada struktur data terlepas dari nilai parameternya, seperti Arrays.sort().

Dengan obat generik, itu dilakukan dengan tipe wildcard:

<E extends Comparable<E>> void sort(E[]);

Agar benar-benar bermanfaat, tipe wildcard memerlukan penangkapan wildcard, dan itu memerlukan gagasan tentang parameter tipe. Tidak ada yang tersedia pada saat array ditambahkan ke Jawa, dan membuat array tipe referensi kovarian memungkinkan cara yang jauh lebih sederhana untuk mengizinkan algoritma polimorfik:

void sort(Comparable[]);

Namun, kesederhanaan itu membuka celah pada sistem tipe statis:

String[] strings = {"hello"};
Object[] objects = strings;
objects[0] = 1; // throws ArrayStoreException

membutuhkan pemeriksaan runtime dari setiap akses tulis ke berbagai jenis referensi.

Singkatnya, pendekatan yang lebih baru yang diwujudkan oleh obat generik membuat sistem tipe lebih kompleks, tetapi juga tipe yang lebih aman, sedangkan pendekatan yang lebih lama lebih sederhana, dan tipe yang kurang aman secara statis. Para perancang bahasa memilih untuk pendekatan yang lebih sederhana, memiliki hal-hal yang lebih penting untuk dilakukan daripada menutup celah kecil dalam sistem tipe yang jarang menyebabkan masalah. Kemudian, ketika Java didirikan, dan kebutuhan mendesak diatasi, mereka memiliki sumber daya untuk melakukannya dengan benar untuk generik (tetapi mengubahnya untuk array akan merusak program Java yang ada).

Generik tidak berubah : dari JSL 4.10 :

... Subtipe tidak meluas melalui tipe generik: T <: U tidak menyiratkan bahwa C<T><: C<U>...

dan beberapa baris lebih jauh, JLS juga menjelaskan bahwa
Array adalah kovarian (peluru pertama):

4.10.3 Subtipe di antara Jenis Array

Saya pikir mereka membuat keputusan yang salah pada awalnya yang membuat array kovarian. Itu merusak keamanan jenis seperti yang dijelaskan di sini dan mereka terjebak dengan itu karena kompatibilitas ke belakang dan setelah itu mereka mencoba untuk tidak membuat kesalahan yang sama untuk generik. Dan itulah salah satu alasan mengapa Joshua Bloch lebih memilih daftar daripada di Item 25 buku "Java Efektif (edisi kedua)"

Saya ambil: Ketika kode mengharapkan array A [] dan Anda memberinya B [] di mana B adalah subkelas A, hanya ada dua hal yang perlu dikhawatirkan: apa yang terjadi ketika Anda membaca elemen array, dan apa yang terjadi jika Anda menulis Itu. Jadi tidak sulit untuk menulis aturan bahasa untuk memastikan bahwa keamanan tipe dipertahankan dalam semua kasus (aturan utama adalah bahwa pelemparan huruf ArrayStoreExceptionbisa dilemparkan jika Anda mencoba memasukkan A ke dalam B []). Namun, untuk generik, ketika Anda mendeklarasikan sebuah kelas SomeClass<T>, mungkin ada sejumlah cara Tyang digunakan dalam tubuh kelas, dan saya menduga itu terlalu rumit untuk mengerjakan semua kombinasi yang mungkin untuk menulis aturan tentang kapan hal-hal diperbolehkan dan ketika tidak.