1. Generische Klassen
1.1 Normale Generika
Die Codekopie lautet wie folgt:
Paket test.lujianing;
/**
* Generische Klasse
* @param <t>
*/
Klassentest <t> {
privat t obj;
public void setValue (t obj) {
this.obj = obj;
}
public t getValue () {
System.out.println (obj.getClass (). GetName ());
Rückkehr obj;
}
}
/**
* Testen Sie generische Klassen
*/
öffentliche Klasse testone {
public static void main (String [] args) {
// Testen Sie die Ganzzahl generic
Test <Ganzzahl> t1 = neuer Test <Ganzzahl> ();
T1.SetValue (5);
Integer i = t1.getValue ();
System.out.println (i);
// testen Sie den doppelten Generikum
Test <Double> t2 = neuer Test <double> ();
t2.setValue (5,55d);
Double d = t2.getValue ();
System.out.println (d);
// Tester String Generikum
Test <string> t3 = neuer Test <string> ();
t3.setValue ("Hallo Welt");
String str = t3.getValue ();
System.out.println (str);
}
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
Java.lang.Integer
5
java.lang.double
5.55
Java.lang.String
Hallo Welt
1,2 K/V Generika
Die Codekopie lautet wie folgt:
Paket test.lujianing;
import Java.util.hashMap;
import Java.util.map;
/**
* Erstellt von Administrator am 14.30.30 Uhr.
*/
Klasse testkv <k, v> {
private map <k, v> map = new HashMap <k, v> ();
public void put (k k, v v) {
map.put (k, v);
}
public v Get (k k) {
return map.get (k);
}
}
public class testfour {
public static void main (String [] args) {
Testkv <string, string> t = neuer testkv <string, string> ();
T.Put ("Name", "Jianing");
System.out.println (T.get ("Name"));
Testkv <String, Integer> T2 = neuer testkv <string, Integer> ();
t2.put ("Alter", 24);
System.out.println (t2.get ("Alter"));
}
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
Jianing
vierundzwanzig
2. Generische Schnittstelle
Die Codekopie lautet wie folgt:
Paket test.lujianing;
/**
* Generische Schnittstelle
* @param <t>
*/
öffentliche Schnittstelle Testimpl <T> {
public void setValue (t t);
öffentlich nicht GetValue ();
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
1
Hallo Wort
3. Generische Methoden
Die Codekopie lautet wie folgt:
Paket test.lujianing;
/**
* Generische Methodenklasse
*/
Klasse testMethod {
/**
* Generische Methoden
*/
public <t> t GetValue (Objekt S, Klasse <T> Clazz) {
System.out.println (clazz.getName ());
T t = null;
if (clazz.getName (). Equals ("java.lang.Inegier")) {
Double d = double.Parsedouble (S.ToString ());
int i = d.intValue ();
t = (t) New Integer (i);
}
if (clazz.getName (). Equals ("java.lang.double")) {
t = (t) neues double (s.tostring ());
}
return t;
}
}
/**
* Generische Methode -Testklasse
*/
public class testhree {
public static void main (String [] args) {
TestMethod t = neuer testMethod ();
int i = t.getValue ("30.0011", Integer.class);
System.out.println (i);
double d = t.getValue ("40.0022", double.class);
System.out.println (d);
}
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
Java.lang.Integer
30
java.lang.double
40.0022
4. Generika einschränken
Im obigen Beispiel gibt es keine Grenze für den Bereich des Klassentests <T> -Typhalters T, und der Standardeinschränkungstyp entspricht dem Objekt. Zum Beispiel müssen wir T auf den digitalen Schnittstellentyp beschränken. Tun Sie dies: Klassentest erweitert die Nummer>.
5. Wild Generics
Die Codekopie lautet wie folgt:
Paket test.lujianing;
import Java.util.hashMap;
import Java.util.map;
/**
* Wilde Generika
*/
public class testfive {
public static void main (String [] args) {
Karte <String, Klasse <?
map.put ("Integer", Integer.class);
map.put ("double", double.class);
für (map.entry <String, Klasse <? Erweitert Nummer >> Eintrag: map.EntrySet ()) {
System.out.println ("Schlüssel:" + Eintrag.Getkey () + "Wert:" + Eintrag.getValue ());
}
}
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
Schlüssel: Doppelwert: Klasse java.lang.double
Schlüssel: Integer Value: Klasse Java.lang.Integer
Einfaches Beispiel: Beispiel für 1.1
Die Codekopie lautet wie folgt:
public static void main (String [] args) {
// Testen Sie die Ganzzahl generic
Test <Ganzzahl> t1 = neuer Test <Ganzzahl> ();
T1.SetValue (5);
Spaß (T1);
// testen Sie den doppelten Generikum
Test <Double> t2 = neuer Test <double> ();
t2.setValue (5,55d);
Spaß (T2);
}
public static void Fun (Test <?> T) {
System.out.println ("wild generic" + t.getValue ());
}
Ausgangsergebnis:
Die Codekopie lautet wie folgt:
Java.lang.Integer
Wild Generics 5
java.lang.double
Wild Generics 5.55
6. Ergänzung
In Generika können Sie <t> <e> usw. t und e die Initialen vom Typ und Element begegnen. E wird im Allgemeinen verwendet, um die Art der Elemente im Sammelstyp darzustellen, z. B. die Definition der List -Schnittstelle und die öffentliche Schnittstellenliste <e> erweitert die Sammlung <e>. Dies ist nur eine Namensgewohnheit, und es gibt keinen wesentlichen Unterschied zwischen den beiden.