La forma más fácil de comprender Java Generics es considerarlo como una sintaxis conveniente que puede ahorrarle algunas operaciones en el casting de tipo Java:
Lista <Apple> Box = ...; Apple Apple = box.get (0);
El código anterior en sí mismo se ha expresado claramente: el cuadro es una lista con objetos de Apple. El método GET devuelve una instancia de objeto Apple, y este proceso no requiere una conversión de tipo. No hay genéricos, el código anterior debe escribirse así:
Box de lista = ...; Apple Apple = (Apple) Box.get (0);
Es obvio que el beneficio principal de los genéricos es permitir que el compilador retenga la información de tipo de los parámetros, realice las verificaciones de tipo y realice operaciones de conversión de tipo: el compilador asegura que estas conversiones de tipo sean absolutamente correctas. En comparación con confiar en los programadores para recordar los tipos de objetos y realizar conversiones de tipo: esto causará fallas cuando se ejecute el programa, lo cual es difícil de depurar y resolver. El compilador puede ayudar a los programadores a forzar una gran cantidad de verificaciones de tipo en el tiempo de compilación y encontrar errores.
La composición de los genéricos
La composición de los genéricos conduce al concepto de variables de tipo. Según la especificación del lenguaje Java, las variables de tipo son un tipo de glifo sin restricciones, que surge de las siguientes situaciones:
Declaración de clase genérica Declaración de interfaz genérica Declaración de método genérico Declaración del constructor genérico
Clases e interfaces genéricas
Si hay una o más variables de tipo en una clase o interfaz, es genérico. Las variables de tipo se definen mediante soportes de ángulo y se colocan después del nombre de la clase o interfaz:
Lista de interfaz pública <T> extiende la colección <T> {...}En pocas palabras, el papel de las variables de tipo es como un parámetro, que proporciona información al compilador para la verificación de tipo.
Muchas clases en la biblioteca de clase Java, como todo el marco de la colección, se han modificado en forma genérica. Por ejemplo, la interfaz de lista que utilizamos en el primer código anterior es una clase genérica. En ese código, el cuadro es un objeto de lista <Apple>, que es una instancia de una implementación de clase de una interfaz de lista con una variable de tipo Apple. El compilador utiliza este tipo de parámetro variable para convertir automáticamente el método GET cuando se llama y devuelve un objeto Apple.
De hecho, esta etiqueta genérica recientemente emergente, o el método GET en esta interfaz de lista, es la siguiente:
T get (int index);
El método GET realmente devuelve un objeto de tipo T, que es una variable de tipo en la declaración de la lista <t>.
Métodos y constructores genéricos
Muy similar, si se declaran una o más variables de tipo en el método y el constructor, también pueden ser genéricos.
Public static <t> t getFirst (List <T> List)
Este método aceptará una lista <t> parámetro y devolverá un objeto de tipo T. Puede usar las clases genéricas proporcionadas en la biblioteca de clases Java, o puede usar sus propias clases genéricas. Datos de escritura de tipo seguro ... El siguiente código es un ejemplo. Creamos una instancia de la lista <string> y luego cargamos algunos datos:
List <String> str = new ArrayList <String> (); str.add ("hola"); str.add ("mundo");Si intentamos cargar otro objeto en la lista <String>, el compilador solicitará un error:
str.add (1);
Datos de lectura a prueba de seguridad ...
Cuando estamos utilizando un objeto Lista <String>, siempre garantiza que obtengamos un objeto de cadena:
String myString = str.get (0);
Traversal: muchas clases en la biblioteca de clases, como Iterator <T>, tienen funciones mejoradas y están genérados. El método iterator () en la interfaz de la lista <t> ahora devuelve Iterator <T>. El objeto devuelto por su método T Next () no necesita ser convertido de tipo, obtiene directamente el tipo correcto.
for (iterator <String> iter = str.iterator (); iter.hasnext ();) {string s = iter.next (); system.out.print (s);}Con Foreach, la sintaxis "para cada" también se beneficia de los genéricos. El código anterior se puede escribir así:
for (string s: str) {system.out.print (s);}Esto es fácil de leer y mantener.
Encapsulación automática (autoboxing) y desempaquetado automático (autounboxing). Al usar Java Generics, las dos características de AutoBoxing/Autounboxing se utilizarán automáticamente, al igual que el siguiente código:
List <Integer> ints = new ArrayList <Integer> (); ints.add (0); ints.add (1); int sum = 0; para (int i: ints) {sum += i; }Sin embargo, una cosa que debe comprender es que el embalaje y el desempaquetado traerán pérdidas de rendimiento, y todo, el propósito general debe usarse con precaución.
Los genéricos son una nueva característica de Java SE 1.5. La esencia de genéricos es un tipo parametrizado, es decir, el tipo de datos operado se especifica como un parámetro. Este tipo de parámetro se puede utilizar en la creación de clases, interfaces y métodos, y se llama clases genéricas, interfaces genéricas y métodos genéricos respectivamente.
La ventaja de introducir genéricos en el lenguaje Java es que son seguros y simples.
Antes de Java SE 1.5, sin genéricos, la "arbitrariario" de los parámetros se logró haciendo referencia al objeto tipo. La desventaja de la "arbitrariario" fue que se requería una conversión explícita del tipo de lanzamiento, y esta conversión requirió que los desarrolladores predecieran el tipo de parámetro real. En el caso de los errores de conversión de tipo de lanzamiento, el compilador puede no provocar un error, y una excepción solo ocurrirá cuando se ejecute, lo cual es un riesgo de seguridad.
La ventaja de los genéricos es que verifican la seguridad del tipo al compilarse, y todos los moldes son automáticos e implícitos, lo que mejora la tasa de reutilización de código.
Hay algunas reglas y restricciones en el uso de genéricos:
1. Los parámetros de tipo de tipos genéricos solo pueden ser tipos de clases (incluidas las clases personalizadas), no los tipos simples.
2. El mismo tipo genérico puede corresponder a múltiples versiones (porque el tipo de parámetro es incierto), y las instancias de clase genérica de diferentes versiones son incompatibles.
3. Puede haber parámetros de tipo múltiple para genéricos.
4. Los tipos de parámetros genéricos pueden usar declaraciones extendidas, por ejemplo. Habitualmente convirtiéndose en un "tipo limitado".
5. El tipo de parámetro de un tipo genérico también puede ser un tipo comodín. Por ejemplo, clase Classtype = class.forname (java.lang.string);
Los genéricos también tienen interfaces, métodos, etc., con mucho contenido, y se necesita algo de esfuerzo para comprender, dominarlas y aplicarlas de manera competente. Aquí hay dos ejemplos que escribí cuando aprendí sobre genéricos (escritos basados en la impresión que vi), que pueden realizar la misma función. Uno usa genéricos y el otro no. A través de la comparación, puede aprender rápidamente la aplicación de genéricos. Aprenda esto y básicamente aprenda el 70% del contenido de genéricos.
Ejemplo 1: se utilizan genéricos
clase pública gent {private t ob; // Definir el miembro genérico Variable Public Gen (t OB) {this.ob = ob; } public t getob () {return ob; } public void setob (t ob) {this.ob = ob; } public void showTyep () {System.out.println ("El tipo real de t es:" + ob.getClass (). getName ()); }} public class Gendemo {public static void main (string [] args) {// Definir una versión entera de la clase genérica gen geniB = new GenInteger (88); intob.showtyep (); int i = intob.getOb (); System.out.println ("value =" + i); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------Ejemplo 2: No se usan genéricos
clase pública gen2 {objeto privado ob; // Definir un miembro de tipo general Public Gen2 (Object OB) {this.ob = ob; } Public Object getob () {return OB; } public void setob (objeto ob) {this.ob = ob; } public void showTyep () {System.out.println ("El tipo real de t es:" + ob.getClass (). getName ()); }}public class GenDemo2 { public static void main(String[] args) {//Define an Integer version of class Gen2 Gen2 intOb = new Gen2(new Integer(88));intOb.showTyep();int i = (Integer) intOb.getOb();System.out.println("value= " + i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getob (); system.out.println ("value =" + s);Resultados de ejecución:
Los resultados de ejecutar la demostración en los dos ejemplos son los mismos, y 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
valor = hola gen!
Proceso terminado con el código de salida 0
Si comprende esto, no será un problema en el futuro cuando las aplicaciones genéricas básicas y la lectura de código.
Lo anterior es un análisis de ejemplo de Java Generics. Los amigos que aprenden genéricos Java pueden referirse a él.