Menggunakan generik boleh meningkatkan keselamatan jenis dan kebolehgunaan semula kod Java. Jawapannya ialah generik mesti digunakan untuk mengelakkan kesilapan runtime dan mengurangkan penukaran jenis; 1. Generik boleh memeriksa keselamatan jenis pada masa penyusunan, menghapuskan pelakon, dan meningkatkan kejelasan kod; 2. Generik boleh ditakrifkan untuk merangkum mana-mana jenis, untuk melaksanakan operasi data yang selamat; 3. Gunakan parameter jenis yang dibatasi seperti untuk mengehadkan skop jenis generik untuk memastikan jenis kesahihan; 4. Wildcards? ,? memanjangkan t dan? Super T mewakili jenis yang tidak diketahui, terikat atas dan terikat bawah masing -masing, mengikut prinsip PECS (Pengeluar menggunakan Extends, pengguna menggunakan super) untuk meningkatkan fleksibiliti; 5. Kaedah generik boleh menentukan parameter jenis secara bebas daripada kelas, kesimpulan jenis sokongan, dan memudahkan panggilan; 6. Java Generik didasarkan pada jenis pemadaman, dan tidak ada maklumat jenis selepas penyusunan, mengakibatkan ketidakupayaan untuk memberi instantate t atau instanceof checking, dan array generik tidak dapat dibuat; 7. Amalan terbaik termasuk sentiasa menggunakan generik untuk koleksi, mengutamakan kad liar yang dibatasi, menamakan parameter jenis spesifikasi, mengelakkan jenis primitif dan mengendalikan amaran yang tidak terkawal; Selepas menguasai konsep teras ini, generik akan meningkatkan kualiti dan pemeliharaan kod dengan ketara.

Generik di Java adalah salah satu ciri yang paling kuat yang diperkenalkan di Java 5, membolehkan pemaju menulis kod fleksibel, boleh diguna semula, dan selamat jenis . Dengan menggunakan generik, anda boleh menangkap bug pada masa penyusunan dan bukannya runtime, mengurangkan pemutus, dan meningkatkan kejelasan kod. Jika anda menulis kod Java hari ini -terutamanya dengan koleksi, struktur data tersuai, atau API -penyusunan generik adalah penting.

Mari kita pecahkan cara menggunakan generik dengan berkesan untuk menulis kod yang lebih selamat, bersih, dan lebih banyak.

1. Apakah generik dan mengapa menggunakannya?

Generik membolehkan anda menentukan kelas, antara muka, dan kaedah dengan parameter jenis . Daripada bekerja dengan Object dan pemutus, anda bekerja dengan jenis tertentu yang diketahui pada masa penyusunan.

Sebelum generik (buruk):

 Senarai Senarai = ArrayList baru ();
list.add ("Hello");
String s = (string) list.get (0); // tidak selamat: boleh membuang classcastexception

Dengan generik (baik):

 Senarai <string> list = arrayList baru <> ();
list.add ("Hello");
String s = list.get (0); // Tiada pelakon yang diperlukan, jenis selamat

? Faedah:

• Pemeriksaan jenis masa kompilasi
• Menghapuskan keperluan untuk pemutus eksplisit
• Membolehkan menulis kod boleh diguna semula dalam pelbagai jenis

2. Kelas dan antara muka generik

Anda boleh membuat kelas dan antara muka generik anda sendiri dengan memperkenalkan parameter jenis.

Contoh: Kotak generik sederhana

 Kotak Kelas Awam <T> {
    nilai t swasta;

    set void awam (nilai t) {
        this.value = value;
    }

    awam t get () {
        nilai pulangan;
    }
}

Sekarang anda boleh menggunakannya dengan selamat:

 Kotak <string> stringbox = kotak baru <> ();
Stringbox.set ("Hi");
String content = stringbox.get (); // Tiada pelakon, jenis selamat

Anda juga boleh mempunyai pelbagai jenis parameter:

 pasangan kelas awam <t, u> {
    swasta t pertama;
    u swasta kedua;
    // pembina, getters ...
}

3. Parameter jenis yang dibatasi untuk kekangan

Kadang -kadang anda ingin menyekat jenis yang boleh digunakan dengan generik. Gunakan parameter jenis yang dibatasi dengan extends .

Contoh: Hanya membenarkan jenis yang memanjangkan nombor

 Kalkulator Kelas Awam <t Extends Number> {
    Tambah dua kali ganda (t a, t b) {
        kembali A.DoBlevalue () b.doublevalue ();
    }
}

Sekarang ini berfungsi:

 Calculator <Integer> calc = New Calculator <> ();
calc.add (5, 10); // ok

Tetapi ini akan gagal pada masa penyusunan:

 Kalkulator <string> calc = calculator baru <> (); // Kompilasi ralat!

Anda juga boleh menggunakan Wildcards Bounded ( ? extends T , ? super T ) untuk lebih fleksibiliti dalam parameter kaedah.

4. Wildcards : ? , ? extends , dan ? super

Wildcards membantu apabila anda perlu bekerja dengan jenis yang tidak diketahui semasa mengekalkan keselamatan jenis.

? - Wildcard yang tidak terkawal

Gunakan apabila anda hanya perlu membaca atau beroperasi secara amnya.

 public void printList (senarai <?> senarai) {
    untuk (item objek: senarai) {
        System.out.println (item);
    }
}

? extends T - kad liar yang dibatasi atas

Membolehkan mana -mana subtipe T. Berguna untuk senario pengeluar (misalnya, membaca dari senarai).

 Jumlah Double Public (Senarai <? Extends Number> Number) {
    kembali nombor.stream ()
                  .maptodouble (nombor :: doublevalue)
                  .sum ();
}

Ini menerima List<Integer> , List<Double> , dll.

? super T - kad liar yang dibatasi lebih rendah

Membolehkan mana -mana supertype T. Ideal untuk senario pengguna (contohnya, menambah senarai).

 public void addNumbers (senarai <? super integer> list) {
    list.add (1);
    list.add (2);
}

Menerima List<Integer> , List<Number> , atau List<Object> .

? Ingat PECS : Pengeluar- extends , Consumer- super .

5. Kaedah Generik

Anda boleh menentukan kaedah dengan parameter jenis mereka sendiri, bebas daripada kelas.

 kelas awam menggunakan {
    public static <t> void printall (senarai <t> item) {
        untuk (t item: item) {
            System.out.println (item);
        }
    }
}

Panggilnya tanpa menentukan jenisnya secara eksplisit -Java menyenaraikannya:

 Senarai <string> names = arrays.aslist ("Alice", "bob");
Util.printall (nama); // t disimpulkan sebagai rentetan

6. Erasure dan batasan

Generik Java Gunakan Jenis Pemadaman -Maklumat Jenis Generik dikeluarkan pada masa runtime. Ini bermaksud:

• Anda tidak boleh meneliti new T() atau periksa if (obj instanceof T)
• Tidak ada beban yang hanya berdasarkan jenis generik yang berbeza
• Penciptaan pelbagai jenis generik tidak dibenarkan: new T[10] → ralat penyusunan

Tetapi perdagangan adalah keserasian mundur dan tiada overhead runtime.

7. Amalan terbaik untuk menggunakan generik

Untuk menulis kod generik yang mantap dan boleh dipelihara:

• ? Sentiasa gunakan generik dengan koleksi
• ? lebih suka kad liar yang dibatasi apabila fleksibiliti diperlukan
• ? Gunakan nama parameter jenis yang bermakna (misalnya, T untuk jenis, K/V untuk kunci/nilai)
• ? Elakkan jenis mentah -mereka mengalahkan tujuan generik
• ? Jangan abaikan amaran yang tidak terkawal -mereka sering menunjuk kepada isu -isu sebenar

Menguasai generik mengambil amalan, tetapi apabila anda memahami konsep teras -jenis parameter, wildcard, batas, dan penghapusan -anda akan menulis kod yang bukan sahaja lebih selamat tetapi juga lebih ekspresif dan boleh diguna semula.

Pada asasnya, jika anda tidak menggunakan generik di Jawa moden, anda melakukan salah. Mulakan kecil, gunakannya secara konsisten, dan tidak lama lagi mereka akan berasa semula jadi.

Atas ialah kandungan terperinci Menguasai Generik di Java untuk Kod Jenis-selamat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!