¿Qué son los genéricos?
En primer lugar, necesita conocer la definición de "genéricos": los genéricos son una nueva característica de Java SE 1.5. La esencia de los genéricos es un tipo parametrizado, lo que significa que el tipo de datos que se opera es. especificado como parámetro. Este tipo de parámetro se puede utilizar en la creación de clases, interfaces y métodos, denominados clases genéricas, interfaces genéricas y métodos genéricos, respectivamente. La ventaja de introducir genéricos en el lenguaje Java es la seguridad y la simplicidad. Antes de Java SE 1.5, en ausencia de genéricos, los parámetros "arbitrarios" se implementaban mediante referencias al tipo Objeto. La desventaja de "arbitrario" era que se requería una conversión de tipo forzada explícita, y esta conversión requiere que los desarrolladores conozcan los tipos de parámetros reales. antemano. Para errores de conversión de tipos forzados, es posible que el compilador no genere un error y se producirá una excepción durante el tiempo de ejecución. Esto es un riesgo para la seguridad. La ventaja de los genéricos es que la seguridad de tipos se verifica durante la compilación y todas las conversiones son automáticas e implícitas, lo que mejora la reutilización del código. En segundo lugar, sus reglas y restricciones: 1. Los parámetros de tipo de los genéricos solo pueden ser tipos de clase (incluidas las clases personalizadas), no tipos simples. 2. El mismo tipo genérico puede corresponder a múltiples versiones (porque el tipo de parámetro es incierto) y diferentes versiones de instancias de clases genéricas son incompatibles.
3. Los genéricos pueden tener múltiples parámetros de tipo.
4. Los tipos de parámetros genéricos pueden utilizar la instrucción extends, como
5. El tipo de parámetro de un tipo genérico también puede ser un tipo comodín.
Por ejemplo, Class> classType = Class.forName(java.lang.String);
Ejemplo: Ejemplo 1: uso de genéricos
public class Gen private T ob; //Definir variables miembro genéricas public Gen(T ob) { this.ob = ob; } público T getOb() { return ob; } público void setOb(T ob) { p > this.ob = ob; } public void showTyep() { System.out.println("El tipo real de T es: " + ob.getClass().getName()); } } clase pública GenDemo { public static void main(String[] args){ //Definir una versión entera de la clase genérica Gen Gen intOb.showTyep(); int i= intOb.getOb(); System.out.println("valor= " + i) ; System.out.println("----------------------------------- -------------"); //Definir una versión String de la clase genérica Gen Gen strOb.showTyep(); String s=strOb.getOb(); System.out. println("value= " + s); } } Ejemplo 2: No se utilizan genéricos clase pública Gen2 { objeto privado ob; //Definir miembros de tipo general public Gen2(Objeto ob) { this.ob = ob; } objeto público getOb() { return ob; } objeto público void (objeto ob) { this.ob = ob; } public void showTyep() { System.out.println("El valor real el tipo de T es: " + ob.getClass().getName()) ; } } clase pública GenDemo2 { public static void main(String[] args) { //Definir una versión entera de la clase Gen2 Gen2 intOb = new Gen2(new Integer(88)); intOb.showTyep(); >int i = (Entero) intOb.getOb(); System.out.println("value=" + i); System.out.println("-- -----------------"); //Definir una cadena de clase Gen2 Versión Gen2 strOb = new Gen2("¡Hola Gen!"); strOb.showTyep(); Cadena s = (Cadena) strOb.getOb (); System.out.println("value= " + s); } } Resultados de la ejecución: Los resultados de ejecutar la demostración en los dos ejemplos son los mismos. La salida de la consola es la siguiente: El tipo real de T es: java. .lang.Integer valor= 88 --------------------- ------- El tipo real de T es: java.lang.String value= ¡Hola general! Proceso finalizado con código de salida 0