1. Classes genéricas
1.1 genéricos normais
A cópia do código é a seguinte:
pacote test.lujianing;
/**
* Classe genérica
* @param <T>
*/
classe teste <T> {
privado t obj;
public void SetValue (T Obj) {
this.obj = obj;
}
public T getValue () {
System.out.println (obj.getclass (). GetName ());
retornar obj;
}
}
/**
* Teste as classes genéricas
*/
classe pública Testone {
public static void main (string [] args) {
// Teste o Inteiro genérico
Teste <Teger> t1 = novo teste <Teger> ();
t1.setValue (5);
Inteiro i = t1.getValue ();
System.out.println (i);
// Teste o duplo genérico
Teste <OWLOUL> T2 = novo teste <OWLOUE> ();
T2.SetValue (5.55D);
Duplo d = t2.getValue ();
System.out.println (d);
// Test String genérico
Teste <string> t3 = novo teste <String> ();
T3.SetValue ("Hello World");
String str = t3.getValue ();
System.out.println (str);
}
}
Resultado da saída:
A cópia do código é a seguinte:
java.lang.integer
5
java.lang.double
5.55
java.lang.string
Olá mundo
1.2 K/V genéricos
A cópia do código é a seguinte:
pacote test.lujianing;
importar java.util.hashmap;
importar java.util.map;
/**
* Criado pelo administrador em 14-3-30.
*/
classe testkv <k, v> {
mapa privado <k, v> map = novo hashmap <k, v> ();
public void put (k k, v v) {
map.put (k, v);
}
public v get (k k) {
retorno map.get (k);
}
}
classe pública testfour {
public static void main (string [] args) {
Testkv <string, string> t = new testkv <string, string> ();
t.put ("nome", "jianing");
System.out.println (t.get ("nome"));
Testkv <string, número inteiro> t2 = new testkv <string, integer> ();
t2.put ("idade", 24);
System.out.println (t2.get ("idade"));
}
}
Resultado da saída:
A cópia do código é a seguinte:
Jianing
vinte e quatro
2. Interface genérica
A cópia do código é a seguinte:
pacote test.lujianing;
/**
* Interface genérica
* @param <T>
*/
Public Interface Testimpl <T> {
public void SetValue (T t);
public T getValue ();
}
Resultado da saída:
A cópia do código é a seguinte:
1
Olá palavra
3. Métodos genéricos
A cópia do código é a seguinte:
pacote test.lujianing;
/**
* Classe de método genérico
*/
classe testmethod {
/**
* Métodos genéricos
*/
public <t> t getValue (objeto s, classe <t> clazz) {
System.out.println (clazz.getName ());
T t = nulo;
if (clazz.getName (). Equals ("java.lang.integer")) {
Duplo d = duplo.parsedouble (s.toString ());
int i = d.IntValue ();
t = (t) novo número inteiro (i);
}
if (clazz.getName (). Equals ("java.lang.double")) {
t = (t) novo duplo (s.toString ());
}
retornar t;
}
}
/**
* Classe de teste de método genérico
*/
classe pública TestThree {
public static void main (string [] args) {
TestMethod t = new TestMethod ();
int i = t.getValue ("30.0011", Integer.class);
System.out.println (i);
duplo d = t.getValue ("40.0022", duplo.class);
System.out.println (d);
}
}
Resultado da saída:
A cópia do código é a seguinte:
java.lang.integer
30
java.lang.double
40.0022
4. Restre os genéricos
No exemplo acima, não há limite para o intervalo de teste <t> titular do tipo t, e o tipo de restrição padrão é equivalente ao objeto. Por exemplo, precisamos limitar o T ao tipo de interface digital. Basta fazer isso: Teste de classe <T estende o número>.
5. genéricos selvagens
A cópia do código é a seguinte:
pacote test.lujianing;
importar java.util.hashmap;
importar java.util.map;
/**
* Genéricos selvagens
*/
classe pública TestFive {
public static void main (string [] args) {
Mapa <string, classe <?
map.put ("Inteiro", Integer.class);
map.put ("duplo", duplo.class);
para (map.entry <string, classe <? Extende número >> Entrada: map.entrySet ()) {
System.out.println ("key:" + entradas.getKey () + "value:" + entrada.getValue ());
}
}
}
Resultado da saída:
A cópia do código é a seguinte:
Chave: Valor duplo: classe java.lang.double
Chave: Valor inteiro: classe java.lang.integer
Exemplo simples: exemplo para 1.1
A cópia do código é a seguinte:
public static void main (string [] args) {
// Teste o Inteiro genérico
Teste <Teger> t1 = novo teste <Teger> ();
t1.setValue (5);
diversão (t1);
// Teste o duplo genérico
Teste <OWLOUL> T2 = novo teste <OWLOUE> ();
T2.SetValue (5.55D);
diversão (T2);
}
public static void diversão (teste <?> t) {
System.out.println ("Wild Generic" + T.GetValue ());
}
Resultado da saída:
A cópia do código é a seguinte:
java.lang.integer
Wild Generics 5
java.lang.double
Wild Generics 5.55
6. Suplemento
Nos genéricos, você pode encontrar <T> <E>, etc., T e E são as iniciais do tipo e elemento, respectivamente. E é geralmente usado para representar o tipo de elementos no tipo de coleção, como a definição da interface da lista, a lista de interface pública <E> estende a coleção <E>. Este é apenas um hábito de nomenclatura, e não há diferença essencial entre os dois.