Generik Java (Generik) adalah fitur baru yang diperkenalkan di JDK5 yang memungkinkan penggunaan parameter tipe (Parameter Tipe) saat mendefinisikan kelas dan antarmuka. Parameter tipe yang dideklarasikan diganti dengan tipe tertentu saat digunakan. Penerapan generik yang paling penting sekarang ada dalam kerangka kelas koleksi baru di JDK5, di mana Peta dan Daftar digunakan. Keuntungannya sudah jelas. Kita dapat memperluas lebih banyak kelas secara horizontal. Kerugiannya sebenarnya adalah kelebihannya, karena ketika kita menggunakan kelas generik, kita harus sangat jelas tentang tujuan kode kita dan tidak boleh menggunakan tipe kesalahan.
Kelas generik paling dasar
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e1;
/**
* Kelas generik paling dasar, tipenya ditentukan sendiri
* @penulis Garin Zhang
*
* @param<T>
*/
kelas publik Poin<T> {
var T pribadi;
publik T getVar() {
kembali var;
}
kekosongan publik setVar(T var) {
ini.var = var;
}
}
paket com.garinzhang.javabase.generic.e1;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Titik<String> p = Titik baru<String>();
p.setVar("pembuat kode");
Sistem.keluar.println(p.getVar());
}
}
Beberapa tipe generik
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e2;
/**
* Beberapa tipe generik. Umumnya, yang terbaik adalah menggunakan huruf yang dekat dengan T, seperti S, R, dll.
* @penulis Garin Zhang
*
* @param<T>
* @param <S>
*/
Notepad kelas publik<T, S> {
kunci T pribadi;
nilai S pribadi;
publik T getKey() {
kembalikan kunci ini;
}
publik S getValue() {
kembalikan ini.nilai;
}
public void setKey(kunci T) {
this.key = kunci;
}
public void setValue(nilai S) {
this.nilai = nilai;
}
}
paket com.garinzhang.javabase.generic.e2;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Notepad<String, Integer> p = Notepad baru<String, Integer>();
p.setKey("pembuat kode");
p.setValue(99999);
System.out.println("kunci: " + p.getKey());
System.out.println("nilai: " + p.getValue());
}
}
Gunakan wildcard "?" dalam parameter metode
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e3;
/**
* Kunci dari contoh ini ada pada metode utama
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T> {
kunci T pribadi;
publik T getKey() {
kembalikan kunci ini;
}
public void setKey(kunci T) {
this.key = kunci;
}
@Mengesampingkan
String publik keString() {
kembalikan this.key.toString();
}
}
paket com.garinzhang.javabase.generic.e3;
/**
* Gunakan wildcard dalam parameter metode
* @penulis Garin Zhang
*
*/
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<String> i = Info baru<String>();
i.setKey("pembuat kode");
kesenangan (saya);
Info<Bilangan Bulat> j = Info baru<Bilangan Bulat>();
j.setKey(9999);
menyenangkan(j);
}
public static void fun(Info<?> temp) {
System.out.println("Isi: " + suhu);
}
}
Transformasi ke atas gagal
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e4;
/**
* Kunci dari contoh ini ada pada metode utama
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T> {
kunci T pribadi;
publik T getKey() {
kembalikan kunci ini;
}
public void setKey(kunci T) {
this.key = kunci;
}
@Mengesampingkan
String publik keString() {
kembalikan this.key.toString();
}
}
paket com.garinzhang.javabase.generic.e4;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<String> strEg = Info baru<String>();
Info<Objek> objEg;
// Kesalahan kompilasi "Jenis ketidakcocokan: tidak dapat mengonversi dari Info<String> ke Info<Objek>"
//Upcast gagal, String -> Objek
// objEg = strEg;
}
}
Penggunaan obat generik dalam antarmuka
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e5;
/**
* Kunci dari contoh ini ada pada metode utama
* @penulis Garin Zhang
*
* @param<T>
*/
Info antarmuka<T> {
publik T getVar();
}
paket com.garinzhang.javabase.generic.e5;
/**
* Kelas generik
* @penulis Garin Zhang
*
* @param<T>
*/
kelas publik InfoImpl<T> mengimplementasikan Info<T> {
var T pribadi;
InfoImpl publik(T var) {
ini.setVar(var);
}
kekosongan publik setVar(T var) {
ini.var = var;
}
publik T getVar() {
kembalikan ini.var;
}
}
paket com.garinzhang.javabase.generic.e5;
/**
* Kelas non-generik
* @penulis Garin Zhang
*
* @param<T>
*/
kelas publik InfoImpl1 mengimplementasikan Info<String> {
pribadi String var;
InfoImpl1 publik(String var) {
ini.setVar(var);
}
kekosongan publik setVar(String var) {
ini.var = var;
}
String publik getVar() {
kembalikan ini.var;
}
}
paket com.garinzhang.javabase.generic.e5;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<String> strEg = InfoImpl<String> baru("coder");
System.out.println("Isi: " + strEg.getVar());
Info<String> strEg1 = InfoImpl1 baru("coder1");
System.out.println("Isi: " + strEg1.getVar());
}
}
Wildcard dan penggunaan extends dan super
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e6;
/**
* Kunci dari contoh ini ada pada metode utama
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T> {
kunci T pribadi;
publik T getKey() {
kembalikan kunci ini;
}
public void setKey(kunci T) {
this.key = kunci;
}
@Mengesampingkan
String publik keString() {
kembalikan this.key.toString();
}
}
paket com.garinzhang.javabase.generic.e6;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<String> strEg = Info baru<String>();
strEg.setKey("pembuat kode");
//Kesalahan kompilasi "Metode fun(Info<? extends Number>) dalam tipe GenericExample tidak berlaku untuk argumen (Info<String>)"
// upTypeLimit(i);
// Gunakan tipe Integer atau Angka.
Info<Bilangan Bulat> intEg = Info baru<Bilangan Bulat>();
intEg.setKey(9999);
upTypeLimit(intEg);
//Kesalahan kompilasi "Metode downTypeLimit(Info<? super String>) dalam tipe GenericExample tidak berlaku untuk argumen (Info<Integer>)"
// downTypeLimit(intEg);
// Karena super digunakan, downTypeLimit hanya dapat menerima String itu sendiri dan Object
// Memeriksa hubungan pewarisan String, tidak ada kelas lain yang diwarisi, hanya Objek
downTypeLimit(streg);
Info<Objek> objEg = Info<Objek>();
objEg.setKey(999);
downTypeLimit(objEg);
}
/**
* <? extends T> mewakili batas atas tipe, yang menunjukkan bahwa tipe berparameter mungkin T atau subkelas dari T
* @param suhu
*/
public static void upTypeLimit(Info<? extends Number> temp) {
System.out.println("Isi: " + suhu);
}
/**
* <?super T> mewakili tipe batas bawah (disebut kualifikasi tipe super di Java Core), yang menunjukkan bahwa tipe berparameter adalah tipe super (tipe induk) dari tipe ini, hingga Objek
* Dalam contoh ini berarti T hanya bisa berupa Object atau String, karena String hanya mewarisi dari Object
* @param suhu
*/
public static void downTypeLimit(Info<? super String> temp) {
System.out.println("Isi: " + suhu);
}
}
Metode generik, beberapa generik dalam metode ini
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e7;
/**
* Metode generik, beberapa obat generik dalam metode
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik {
/**
* Format: modifikasi metode <daftar tipe yang dipisahkan koma> mengembalikan nama metode tipe nilai (daftar parameter)
* Contoh: publik <T, S> T menyenangkan(T t, S s)
* @param t
* @param s
* @kembali
*/
publik <T, S> T menyenangkan(T t, S s) {
Sistem.keluar.println(s.toString());
kembali t;
}
}
paket com.garinzhang.javabase.generic.e7;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info info = Info baru();
String str = info.fun("coder", "print parameter generik kedua");
Sistem.keluar.println(str);
int i = info.fun(30, "cetak lagi parameter kedua");
Sistem.keluar.println(i);
}
}
Tipe generik yang diteruskan atau dikembalikan dalam metode ditentukan oleh tipe parameter yang disetel saat metode dipanggil.
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e8;
/**
* meluas
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T memperluas Nomor> {
var T pribadi;
publik T getVar() {
kembalikan ini.var;
}
kekosongan publik setVar(T var) {
ini.var = var;
}
@Mengesampingkan
String publik keString() {
kembalikan ini.var.toString();
}
}
paket com.garinzhang.javabase.generic.e8;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<Integer> intEg = fun(30); // Tipe di sini telah ditentukan menjadi Integer
Sistem.keluar.println(intEg.getVar());
}
/**
* Tipe generik yang diteruskan atau dikembalikan dalam metode ditentukan oleh tipe parameter yang disetel saat memanggil metode.
* @param param
* @kembali
*/
public static <T extends Number> Info<T> fun(T param) {
Info<T> temp = Info baru<T>();
temp.setVar(param);
suhu kembali;
}
}
Jadikan kedua tipe parameter yang diteruskan dalam metode ini konsisten
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e9;
/**
* Lihat utama
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T> {
var T pribadi;
publik T getVar() {
kembalikan ini.var;
}
kekosongan publik setVar(T var) {
ini.var = var;
}
@Mengesampingkan
String publik keString() {
kembalikan ini.var.toString();
}
}
paket com.garinzhang.javabase.generic.e9;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Info<String> i1 = Info baru<String>();
i1.setVar("Halo");
Info<String> i2 = Info baru<String>();
i2.setVar("Pembuat Kode");
Info<Bilangan Bulat> i3 = Info baru<Bilangan Bulat>();
i3.setVar(999);
tambahkan(i1, i2);
//Kesalahan kompilasi "Metode add(Info<T>, Info<T>) dalam tipe GenericExample tidak berlaku untuk argumen (Info<String>, Info<Integer>)"
// tambahkan(i1, i3);
}
/**
* Kedua tipe parameter yang diteruskan dalam metode ini harus konsisten
* @param param
* @kembali
*/
public static <T> batal tambahkan(Info<T> i1, Info<T> i2) {
Sistem.keluar.println(i1.getVar() + ":" + i2.getVar());
}
}
Generik, parameter variabel, mirip dengan objek Argumen di JavaScript
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e10;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Bilangan bulat i[] = kesenangan(1, 2, 3, 4, 5, 6);
kesenangan2(saya);
}
publik statis <T> T[] menyenangkan(T... arg) {
kembali argumen;
}
publik statis <T> void fun2(T param[]) {
System.out.println("array generik: ");
untuk(T t : param) {
Sistem.keluar.println(t + " , ");
}
}
}
Sarang generik: gunakan kelas generik sebagai parameter; tentukan nilai kembalian berdasarkan jenis nilai kembalian
Copy kode kodenya sebagai berikut:
paket com.garinzhang.javabase.generic.e11;
/**
* Menerima dua tipe generik
* @penulis Garin Zhang
*
* @param<T>
*/
Info kelas publik<T, V> {
var T pribadi;
nilai V pribadi;
publik T getVar() {
kembalikan ini.var;
}
kekosongan publik setVar(T var) {
ini.var = var;
}
publik V getValue(){
kembalikan ini.nilai;
}
public void setValue(nilai V) {
this.nilai = nilai;
}
@Mengesampingkan
String publik keString() {
kembalikan ini.var.toString();
}
}
paket com.garinzhang.javabase.generic.e11;
/**
* Menerima 1 tipe generik
* @penulis Garin Zhang
*
* @param<T>
*/
Demo kelas publik<S> {
informasi S pribadi;
Demo publik(Info) {
ini.setInfo(info);
}
kekosongan publik setInfo(S info) {
this.info = info;
}
publik S getInfo() {
kembalikan this.info;
}
}
paket com.garinzhang.javabase.generic.e11;
impor java.util.List;
impor com.google.common.collect.Lists;
Contoh Generik kelas publik {
/**
* @param argumen
*/
public static void main(String[] args) {
Demo<Info<String, Integer>> d;
Info<String, Integer> i;
i = Info baru<String, Integer>();
i.setVar("Pembuat Kode");
i.setValue(999);
d = Demo baru<Info<String,Integer>>(i);
System.out.println("Isi: " + d.getInfo().getVar());
System.out.println("Isi: " + d.getInfo().getValue());
Sistem.keluar.println(kueri(1, 2, 3, 4, 5).toString()); // [1, 2, 3, 4, 5]
// Peringatan "Keamanan tipe: Array generik dari Object&Comparable<?>&Serializable dibuat untuk parameter varargs"
Sistem.keluar.println(query(1, 2, 3, "StringType").toString()); // [1, 2, 3, StringType]
System.out.println(query("Saya ", "saya", "a", "coder").toString());// [Saya , saya , a , pembuat kode]
Daftar<String> daftar = Daftar.newArrayList("Saya", "saya", "a", "coder");
System.out.println(list.toString()); // [Saya , saya , a , pembuat kode]
}
/**
* Tentukan tipe generik melalui nilai kembalian. Tipe nilai kembalian dalam metode ini secara otomatis dihasilkan oleh definisi metode.
* @param elemen
* @kembali
*/
public static <E> Daftar<E> query(E... elemen) {
// https://github.com/exitsoft/exit-web-framework/commit/1d2f1098a2a4b6abab175b793e2308aa8bd0ea16.
//impor com.google.common.collect.Lists;
// <ketergantungan>
// <groupId>com.google.guava</groupId>
// <artifactId>jambu biji</artifactId>
// <versi>16.0.1</versi>
//</ketergantungan>
kembali Daftar.newArrayList(elemen);
}
}