1. El concepto básico de genéricos
Al igual que C#, Java tiene el concepto de genéricos y parametrización de los tipos. Los genéricos en Java aparecen después de JDK5.0, pero los genéricos en Java son esencialmente diferentes de los genéricos en C#. En primer lugar, desde la perspectiva de los tipos de colección, ArrayList <integer> y ArrayList <String> en Java son del mismo tipo. El borrado de tipo se realizará durante la compilación, y los tipos en Java son pseudogenéricos. Los pseudogéneros se introducirán más adelante. En segundo lugar, al agregar tipos básicos de datos a una colección, como INT, INT se convertirá primero en un objeto entero, que es lo que generalmente llamamos la operación de boxeo. Al eliminar elementos, el objeto Interger debe convertirse en un tipo de valor int, es decir, operación de unboxing. En C#, List <St> y List <String> son diferentes tipos. Los parámetros genéricos serán un marcador de posición después de la compilación y no se borran. Se les asigna tipos reales en tiempo de ejecución. Se generan durante el tiempo de ejecución del sistema y tienen sus propias tablas de método virtual y datos de tipo. Esta implementación se llama inflación de tipo (para la inflación de tipo, el compilador instantáneo ha realizado mucho trabajo de optimización para resolver este problema). Este es el llamado verdadero genéricos. Al mismo tiempo, al agregar elementos básicos como INT a una colección, no hay necesidad de boxear, y no se requiere unboxing al eliminar elementos. Por lo tanto, el rendimiento es mejor que Java Collection Generics.
La introducción de genéricos en Java es principalmente para resolver dos problemas: 1. Se producen excepciones de reemplazo de tipo durante el tiempo de ejecución del elemento de tipo de recolección, y las verificaciones de tipo se agregan durante el tipo de tiempo de compilación. 2. Repita la redacción del código durante la solución, y el algoritmo puede reutilizarse. El siguiente es un ejemplo para ilustrar el tipo de verificación del compilador.
Primero, veamos un ejemplo en el que no se usan los genéricos:
ArrayList al = new ArrayList (); Al.add ("ABC"); al.add ("124"); al.add ("32l");Podemos agregar cualquier tipo de datos a la colección AL. Cuando necesitamos convertir el tipo al obtener los datos, como:
String S = (String) Al.get (0); String S1 = (String) Al.get (1); // En el período de ejecución, se informará un error y el error de conversión de tipo será largo l = (largo) al.get (2);
De esto podemos ver que cuando no hay genéricos, la verificación de tipo se reduce durante la compilación. Al eliminar elementos, los programadores deben conocer los tipos de cada elemento, de lo contrario, una excepción de la conversión de tipo puede ocurrir en tiempo de ejecución.
Así que echemos un vistazo a los beneficios que nos brinda a través de colecciones genéricas.
ArrayList <String> al1 = new ArrayList <String> (); AL1.Add ("ABC"); AL1.Add (1); // ocurrió un error durante la compilación,Cuando instanciamos Al1 con el tipo de parámetro de cadena, no podemos agregar un elemento int; de lo contrario, el compilador informará un error. Por lo general, habrá una marca de error en el editor IDE, como Eclipse. Al mismo tiempo, no hay necesidad de escribir la conversión al extraer el elemento.
Valor de cadena = Al1.get (0); // no se requiere conversión de tipo
Este es el beneficio de los genéricos.
Luego, la multiplexación de algoritmos se refleja principalmente en la multiplexación de métodos, como el método Agregar de ArrayList, que puede usarse en cualquier tipo o tipo limitado.
2. Uso de genéricos
Los genéricos en Java se utilizan principalmente en clases, métodos e interfaces. Primero, echemos un vistazo al uso de la clase:
Class Factory <T> {valor t privado; public t getValue () {Valor de retorno; } public void setValue (t v) {this.value = v; }}Agregar método de prueba:
Factory <String> F = New Factory <String> (); F.SetValue ("Fábrica en uso"); System.out.println (f.getValue ());Uso de interfaces genéricas:
interfaz myInterface <t, u> {void show (t t, u u); } La clase ShowTest implementa MyInterface <String, Integer> {@Override public void show (String t, Integer U) {System.out.println (t); System.out.println (U); }}Cuando un parámetro de tipo genérico actúa en una clase, restringe principalmente las restricciones de tipo entre múltiples campos y firmas de métodos. Al actuar en un método, las principales restricciones se realizan en múltiples parámetros del método. Aquí, los parámetros de tipo genérico del método ya no se les dará ejemplos. Presentemos principalmente las restricciones de los parámetros de tipo a continuación.
3. Escriba restricciones de parámetros
Veamos un pequeño ejemplo, como se muestra en el siguiente código:
public static <t> t get (t t1, t t2) {if (t1.compareto (t2)> = 0); // error de compilación, el método comparación (t) no está definido para el tipo t. return t1; }Puede ver el mensaje de error del compilador. El método Compareto no se define para el tipo T. Si los tipos deben compararse en Java, la interfaz comparable debe implementarse, de modo que el método se anule. Luego hacemos las siguientes modificaciones:
public static <t extiende comparable> t get (t t1, t t2) {// Agregar limitación de tipo if (t1.compareto (t2)> = 0); regresar T1; }Al calificar T se extiende comparable, muestra que T es el tipo de interfaz que implementa comparable y, por lo tanto, también implementa el método Compareto, por lo que no habrá errores de tiempo de compilación.
Cuando usamos y para segmentar limitaciones múltiples de los tipos, podemos usar y segmentar las palabras clave limitadas, y solo se pueden usar extensiones. Al mismo tiempo, cuando existen tanto interfaces como tipos, la clase solo se puede colocar primero y solo puede tener una, como se muestra a continuación:
<T extiende objeto y comparable y serializable>
El artículo anterior discute brevemente el papel y los conceptos básicos de Java Generics es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.