1. Clases genéricas
1.1 genéricos normales
La copia del código es la siguiente:
prueba de paquete.lujianing;
/**
* Clase genérica
* @param <t>
*/
prueba de clase <t> {
privado t obj;
public void setValue (t obj) {
this.obj = obj;
}
public t getValue () {
System.out.println (obj.getClass (). GetName ());
regresar obj;
}
}
/**
* Prueba de clases genéricas
*/
testón de clase pública {
public static void main (string [] args) {
// prueba el entero genérico
Test <Integer> t1 = new test <Integer> ();
t1.setValue (5);
Entero i = t1.getValue ();
System.out.println (i);
// Prueba el doble genérico
Test <Oble> t2 = new test <ouble> ();
t2.setValue (5.55d);
Doble d = t2.getValue ();
System.out.println (d);
// Prueba de cadena genérica
Test <String> t3 = new test <String> ();
t3.setValue ("Hola mundo");
Cadena str = t3.getValue ();
System.out.println (str);
}
}
Resultado de salida:
La copia del código es la siguiente:
java.lang.integer
5
java.lang.double
5.55
java.lang.string
Hola Mundo
1.2 k/v genéricos
La copia del código es la siguiente:
prueba de paquete.lujianing;
import java.util.hashmap;
import java.util.map;
/**
* Creado por el administrador el 14-3-30.
*/
clase testkv <k, v> {
mapa privado <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);
}
}
Testfour de clase pública {
public static void main (string [] args) {
TestKv <String, String> t = new testKv <String, string> ();
t.put ("nombre", "jianing");
System.out.println (t.get ("nombre"));
TestKv <String, Integer> t2 = new testKv <String, Integer> ();
t2.put ("edad", 24);
System.out.println (t2.get ("edad"));
}
}
Resultado de salida:
La copia del código es la siguiente:
jianing
veinticuatro
2. Interfaz genérica
La copia del código es la siguiente:
prueba de paquete.lujianing;
/**
* Interfaz genérica
* @param <t>
*/
interfaz pública testempl <t> {
Public nulo setValue (t t);
public t getValue ();
}
Resultado de salida:
La copia del código es la siguiente:
1
hola palabra
3. Métodos genéricos
La copia del código es la siguiente:
prueba de paquete.lujianing;
/**
* Clase de método genérico
*/
clase testMethod {
/**
* Métodos genéricos
*/
public <t> t getValue (Object s, class <t> clazz) {
System.out.println (clazz.getName ());
T t = nulo;
if (clazz.getName (). Equals ("java.lang.integer")) {
Doble d = doble.parsedOuble (s.toString ());
int i = d.intvalue ();
t = (t) nuevo entero (i);
}
if (clazz.getName (). Equals ("java.lang.double")) {
t = (t) nuevo doble (s.ToString ());
}
regresar t;
}
}
/**
* Clase de prueba de método genérico
*/
Public Class TestThree {
public static void main (string [] args) {
TestMethod t = new testMethod ();
int i = t.getValue ("30.0011", integer.class);
System.out.println (i);
doble d = t.getValue ("40.0022", doble.class);
System.out.println (d);
}
}
Resultado de salida:
La copia del código es la siguiente:
java.lang.integer
30
java.lang.double
40.0022
4. Restringir los genéricos
En el ejemplo anterior, no hay límite en el rango del titular de la prueba de clase <T> TIPLADOR T, y el tipo de restricción predeterminado es equivalente al objeto. Por ejemplo, necesitamos limitar T al tipo de interfaz digital. Simplemente haga esto: la prueba de clase <t extiende el número>.
5. Generaciones salvajes
La copia del código es la siguiente:
prueba de paquete.lujianing;
import java.util.hashmap;
import java.util.map;
/**
* Genores salvajes
*/
Public Class TestFive {
public static void main (string [] args) {
Map <cadena, clase <?
map.put ("entero", integer.class);
map.put ("double", double.class);
para (map.entry <string, class <? extiende el número >> Entrada: map.entryset ()) {
System.out.println ("Key:" + Entry.getKey () + "Valor:" + Entry.getValue ());
}
}
}
Resultado de salida:
La copia del código es la siguiente:
Clave: Doble valor: clase java.lang.double
Clave: Valor entero: clase java.lang.integer
Ejemplo simple: ejemplo para 1.1
La copia del código es la siguiente:
public static void main (string [] args) {
// prueba el entero genérico
Test <Integer> t1 = new test <Integer> ();
t1.setValue (5);
diversión (T1);
// Prueba el doble genérico
Test <Oble> t2 = new test <ouble> ();
t2.setValue (5.55d);
diversión (T2);
}
Public static void divers (test <?> t) {
System.out.println ("Wild Generic" + T.getValue ());
}
Resultado de salida:
La copia del código es la siguiente:
java.lang.integer
Genéricos salvajes 5
java.lang.double
Genéricos salvajes 5.55
6. Suplemento
En genéricos, puede encontrar <t> <e>, etc., T y E son las iniciales de tipo y elemento, respectivamente. E se usa generalmente para representar el tipo de elementos en el tipo de colección, como la definición de la interfaz de la lista, la lista de interfaz pública <E> extiende la colección <E>. Esto es solo un hábito de nombres, y no hay una diferencia esencial entre los dos.