1. Classes génériques
1.1 génériques normaux
La copie de code est la suivante:
package test.lujianing;
/ **
* Classe générique
* @param <T>
* /
Classe Test <T> {
TOBJ privé;
public void setValue (t obj) {
this.obj = obj;
}
public t getValue () {
System.out.println (obj.getClass (). GetName ());
retour obj;
}
}
/ **
* Tester les classes génériques
* /
classe publique Testone {
public static void main (String [] args) {
// tester l'entier générique
Test <Integer> t1 = nouveau test <inger> ();
t1.setValue (5);
Entier i = t1.getValue ();
System.out.println (i);
// tester le double générique
Test <bouble> t2 = new test <rouble> ();
t2.SetValue (5.55d);
Double d = t2.GetValue ();
System.out.println (D);
// Test String générique
Test <string> t3 = nouveau test <string> ();
T3.SetValue ("Hello World");
String str = t3.getValue ();
System.out.println (STR);
}
}
Résultat de sortie:
La copie de code est la suivante:
java.lang.integer
5
java.lang.double
5.55
java.lang.string
Bonjour le monde
1,2 k / v génériques
La copie de code est la suivante:
package test.lujianing;
import java.util.hashmap;
importation java.util.map;
/ **
* Créé par l'administrateur le 14-3-30.
* /
classe testkv <k, v> {
map privé <k, v> map = new hashmap <k, v> ();
Public vide put (k k, v v) {
map.put (k, v);
}
public v get (k k) {
retour map.get (k);
}
}
classe publique TestFour {
public static void main (String [] args) {
Testkv <string, string> t = new testkv <string, string> ();
t.put ("nom", "jianing");
System.out.println (t.get ("name"));
Testkv <string, entier> t2 = new TestKv <String, Integer> ();
T2.put ("âge", 24);
System.out.println (t2.Get ("Age"));
}
}
Résultat de sortie:
La copie de code est la suivante:
janing
vingt-quatre
2. Interface générique
La copie de code est la suivante:
package test.lujianing;
/ **
* Interface générique
* @param <T>
* /
Témoignage d'interface publique <T> {
public void setvalue (t t);
public t getValue ();
}
Résultat de sortie:
La copie de code est la suivante:
1
bonjour mot
3. Méthodes génériques
La copie de code est la suivante:
package test.lujianing;
/ **
* Classe de méthode générique
* /
classe TestMethod {
/ **
* Méthodes génériques
* /
public <T> t getValue (objet S, classe <T> Clazz) {
System.out.println (Clazz.getName ());
T t = null;
if (Clazz.getName (). Equals ("java.lang.integer")) {
Double d = double.parsedouble (s.toString ());
int i = d.intValue ();
t = (t) Nouvel entier (i);
}
if (Clazz.getName (). Equals ("java.lang.double")) {
t = (t) nouveau double (s.toString ());
}
retour t;
}
}
/ **
* Classe de test de méthode générique
* /
classe publique TestTHree {
public static void main (String [] args) {
TestMethod t = new 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);
}
}
Résultat de sortie:
La copie de code est la suivante:
java.lang.integer
30
java.lang.double
40.0022
4. restreindre les génériques
Dans l'exemple ci-dessus, il n'y a pas de limite sur la plage de détenteur de type de classe <T> Type T, et le type de restriction par défaut est équivalent à l'objet. Par exemple, nous devons limiter T au type d'interface numérique. Faites ceci: le test de classe <T étend le numéro>.
5. génériques sauvages
La copie de code est la suivante:
package test.lujianing;
import java.util.hashmap;
importation java.util.map;
/ **
* Génériques sauvages
* /
classe publique TestFive {
public static void main (String [] args) {
Map <String, classe <?
map.put ("entier", Integer.class);
map.put ("double", double.classe);
for (map.entry <string, class <? étend numéro >> entrée: map.entryset ()) {
System.out.println ("Key:" + Entry.getKey () + "Value:" + Entry.getValue ());
}
}
}
Résultat de sortie:
La copie de code est la suivante:
Clé: double valeur: classe java.lang.double
clé: valeur entière: classe java.lang.integer
Exemple simple: exemple pour 1.1
La copie de code est la suivante:
public static void main (String [] args) {
// tester l'entier générique
Test <Integer> t1 = nouveau test <inger> ();
t1.setValue (5);
plaisir (T1);
// tester le double générique
Test <bouble> t2 = new test <rouble> ();
t2.SetValue (5.55d);
amusant (T2);
}
Public statique void Fun (test <?> t) {
System.out.println ("Wild Generic" + t.GetValue ());
}
Résultat de sortie:
La copie de code est la suivante:
java.lang.integer
Génériques sauvages 5
java.lang.double
Génériques sauvages 5.55
6. Supplément
Dans les génériques, vous pouvez rencontrer <T> <e>, etc., T et E sont les initiales de type et d'élément, respectivement. E est généralement utilisé pour représenter le type d'éléments dans le type de collection, tels que la définition de l'interface de liste, la liste d'interface publique <E> étend la collection <e>. Ce n'est qu'une habitude de dénomination, et il n'y a pas de différence essentielle entre les deux.