Cara termudah untuk memahami java generik adalah dengan menganggapnya sebagai sintaks yang nyaman yang dapat menghemat beberapa operasi pada casting tipe java:
Daftar <pleph> box = ...; Apple Apple = box.get (0);
Kode di atas itu sendiri telah diungkapkan dengan jelas: kotak adalah daftar dengan objek Apple. Metode GET mengembalikan instance objek Apple, dan proses ini tidak memerlukan konversi tipe. Tidak ada obat generik, kode di atas perlu ditulis seperti ini:
Daftar kotak = ...; Apple Apple = (Apple) box.get (0);
Jelas bahwa manfaat utama obat generik adalah untuk memungkinkan kompiler untuk mempertahankan informasi jenis parameter, melakukan pemeriksaan jenis, dan melakukan operasi konversi jenis: kompiler memastikan bahwa konversi jenis ini benar -benar benar. Dibandingkan dengan mengandalkan programmer untuk mengingat jenis objek dan melakukan konversi jenis - ini akan menyebabkan kegagalan ketika program dijalankan, yang sulit untuk debug dan dipecahkan. Kompiler dapat membantu pemrogram memaksa sejumlah besar pemeriksaan jenis pada waktu kompilasi dan menemukan kesalahan.
Komposisi obat generik
Komposisi obat generik mengarah pada konsep variabel tipe. Menurut spesifikasi bahasa Java, jenis variabel adalah jenis mesin terbang yang tidak dibatasi, yang muncul dari situasi berikut:
Deklarasi kelas generik Deklarasi Generik Metode Generik Deklarasi Deklarasi Konstruktor Generik
Kelas dan antarmuka generik
Jika ada satu atau lebih variabel jenis pada kelas atau antarmuka, itu adalah generik. Jenis variabel ditentukan oleh tanda kurung sudut dan ditempatkan setelah kelas atau nama antarmuka:
Daftar Antarmuka Publik <T> Memperluas Koleksi <T> {...}Sederhananya, peran variabel tipe seperti parameter, yang memberikan informasi kepada kompiler untuk pemeriksaan jenis.
Banyak kelas di Perpustakaan Kelas Java, seperti seluruh kerangka kerja koleksi, telah dimodifikasi dalam bentuk generik. Misalnya, antarmuka daftar yang kami gunakan dalam kode pertama di atas adalah kelas generik. Dalam kode itu, Box adalah objek Daftar <PLEP>, yang merupakan instance dari implementasi kelas dari antarmuka daftar dengan variabel tipe Apple. Kompiler menggunakan parameter variabel tipe ini untuk secara otomatis mengonversi metode GET saat dipanggil dan mengembalikan objek Apple.
Bahkan, tag generik yang baru muncul ini, atau metode GET dalam antarmuka daftar ini, adalah sebagai berikut:
T dapat (indeks int);
Metode GET sebenarnya mengembalikan objek tipe T, yang merupakan variabel tipe dalam Daftar <T> Deklarasi.
Metode dan konstruktor generik
Sangat mirip, jika satu atau lebih variabel jenis dinyatakan pada metode dan konstruktor, mereka juga bisa generik.
public static <T> t getFirst (daftar <T> Daftar)
Metode ini akan menerima daftar <T> Parameter dan mengembalikan objek Type T. Anda dapat menggunakan kelas generik yang disediakan di Perpustakaan Kelas Java, atau Anda dapat menggunakan kelas generik Anda sendiri. Tipe-aman menulis data ... kode berikut adalah contoh. Kami membuat daftar <string> instance dan kemudian memuat beberapa data:
Daftar <String> str = new ArrayList <String> (); str.add ("halo"); str.add ("dunia.");Jika kami mencoba memuat objek lain di Daftar <String>, kompiler akan meminta kesalahan:
Str.Add (1);
Tipe-Safe Reading Data ...
Ketika kami menggunakan objek Daftar <String>, selalu menjamin bahwa kami mendapatkan objek string:
String myString = str.get (0);
Traversal: Banyak kelas di perpustakaan kelas, seperti Iterator <T>, memiliki fungsi yang ditingkatkan dan digeneralisasi. Metode iterator () dalam antarmuka daftar <T> sekarang mengembalikan Iterator <T>. Objek yang dikembalikan dengan metode t Next () tidak perlu dikonversi tipe, Anda langsung mendapatkan jenis yang benar.
untuk (iterator <string> iter = str.iterator (); iter.hasnext ();) {string s = iter.next (); system.out.print (s);}Dengan foreach, sintaks "untuk setiap" juga mendapat manfaat dari obat generik. Kode sebelumnya dapat ditulis seperti ini:
untuk (string s: str) {system.out.print (s);}Ini mudah dibaca dan dipelihara.
Enkapsulasi otomatis (autoboxing) dan pembongkaran otomatis (autouncoxing). Saat menggunakan java generik, dua fitur autoboxing/autoouncing akan digunakan secara otomatis, seperti kode berikut:
Daftar <Integer> ints = new ArrayList <Integer> (); ints.add (0); ints.add (1); int sum = 0; untuk (int i: ints) {sum += i; }Namun, satu hal yang perlu Anda pahami adalah bahwa pengemasan dan pembongkaran akan membawa kerugian kinerja, dan semua, tujuan umum harus digunakan dengan hati -hati.
Generik adalah fitur baru Java SE 1.5. Inti dari generik adalah tipe parameter, yaitu, tipe data yang dioperasikan ditentukan sebagai parameter. Jenis parameter ini dapat digunakan dalam pembuatan kelas, antarmuka dan metode, dan masing -masing disebut kelas generik, antarmuka generik, dan metode generik.
Keuntungan memperkenalkan obat generik dalam bahasa Java adalah mereka aman dan sederhana.
Sebelum Java SE 1.5, tanpa obat generik, "arbitrararisasi" parameter dicapai dengan merujuk objek tipe. Kerugian dari "arbitrararisasi" adalah bahwa konversi tipe pemeran eksplisit diperlukan, dan konversi ini mengharuskan pengembang untuk memprediksi tipe parameter aktual. Dalam hal kesalahan konversi tipe pemeran, kompiler mungkin tidak menimbulkan kesalahan, dan pengecualian hanya akan terjadi saat berjalan, yang merupakan risiko keamanan.
Keuntungan dari obat generik adalah bahwa mereka memeriksa keamanan tipe saat menyusun, dan semua gips otomatis dan implisit, meningkatkan tingkat penggunaan kembali kode.
Ada beberapa aturan dan batasan dalam penggunaan obat generik:
1. Parameter tipe tipe generik hanya bisa berupa jenis kelas (termasuk kelas khusus), bukan tipe sederhana.
2. Jenis generik yang sama dapat sesuai dengan beberapa versi (karena tipe parameter tidak pasti), dan contoh kelas generik dari versi yang berbeda tidak kompatibel.
3. Mungkin ada beberapa parameter tipe untuk obat generik.
4. Jenis parameter generik dapat menggunakan pernyataan Extends, misalnya. Biasanya menjadi "tipe terikat".
5. Jenis parameter dari tipe generik juga bisa berupa tipe wildcard. Misalnya kelas classtype = class.forname (java.lang.string);
Generik juga memiliki antarmuka, metode, dll., Dengan banyak konten, dan butuh beberapa upaya untuk memahami, menguasai dan menerapkannya dengan mahir. Berikut adalah dua contoh yang saya tulis ketika saya belajar tentang obat generik (ditulis berdasarkan kesan yang saya lihat), yang dapat mewujudkan fungsi yang sama. Satu menggunakan obat generik dan yang lainnya tidak. Melalui perbandingan, Anda dapat dengan cepat mempelajari aplikasi obat generik. Pelajari ini dan pada dasarnya pelajari 70% konten obat generik.
Contoh 1: generik digunakan
kelas publik gent {private t ob; // Tentukan gen publik variabel generik (t ob) {this.ob = ob; } public t getob () {return ob; } public void setob (t ob) {this.ob = ob; } public void showtyep () {System.out.println ("Tipe T yang sebenarnya adalah:" + ob.getClass (). getName ()); }} kelas publik gendemo {public static void main (string [] args) {// Tentukan versi integer dari gen generik gen gen intob = geninteger baru (88); intob.showtyep (); int i = intob.getob (); System.out.println ("value =" + i); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Contoh 2: tidak ada obat generik yang digunakan
Gen2 kelas publik {objek pribadi ob; // Tentukan gen2 anggota tipe umum gen2 (objek ob) {this.ob = ob; } objek publik getOb () {return ob; } public void setob (objek ob) {this.ob = ob; } public void showtyep () {System.out.println ("Tipe T yang sebenarnya adalah:" + ob.getClass (). getName ()); }}public class GenDemo2 { public static void main(String[] args) {//Define an Integer version of class Gen2 Gen2 intOb = new Gen2(new Integer(88));intOb.showTyep();int i = (Integer) intOb.getOb();System.out.println("value= " + i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getob (); System.out.println ("value =" + s);Hasil Menjalankan:
Hasil menjalankan demo dalam dua contoh adalah sama, dan output konsol adalah sebagai berikut:
Jenis T yang sebenarnya adalah:
java.lang.integer
nilai = 88
----------------------------------
Jenis T yang sebenarnya adalah: java.lang.string
nilai = halo gen!
Proses selesai dengan kode keluar 0
Jika Anda memahami ini, Anda tidak akan menjadi masalah di masa depan ketika aplikasi generik dasar dan membaca kode.
Di atas adalah contoh analisis java generik. Teman yang belajar java generik dapat merujuknya.