Una introducción:
Antes de Javase 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.
2. Parámetros genéricos:
class gen <t> {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 showPe () {System.out.println ("El tipo real de T es:" + ob.getClass (). clase GenericParameter {public static void main (String [] args) {// Definir una versión entera de la clase genérica gen gen <integer> intob = new gen <integer> (100); intob.showType (); int i = intob.getob (); system.out.println ("valor =" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" i); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------- producción:
El tipo real de T es: java.lang.integer
valor = 100
----------------------------------------------------------------------------------------------------------------------------
El tipo real de T es: java.lang.string
Valor = Hola Dylan!
3. Generics:
class GenericSfoo <T> {private t x; public genicsfoo (t x) {this.x = x;} public t getx () {return x;} public void setx (t x) {this.x = x;}} public class de clase publicClass {public static void main (string args []) {genicsfoo <string> strfoo = new neowsfoo <string genericClass {public static void main (string args []) Generics! "); GenericsFoo <Souble> doOFOO = new GenericsFoo <Oble> (new Double (" 33 ")); GenericsFoo <SPET> objfoo = new GenericsFoo <S Object> (nuevo Objeto ()); System.out.println ("Strfoo.getx ="+Strfoo.getx ()); producción:
strfoo.getx = ¡Hello Generics!
doOFOO.GETX = 33.0
objfoo.getx=java.lang.object@1d0fafc
Generics de cuatro limitados:
import java.util.arrayList; import java.util.collection; class CollectionGenfoo <t extiende Collection> {private t x; public CollectionGenfoo (t x) {this.x = x;} public t getx () {return x;} public void setX (t x) {this.x = x;} public en la clase pública genicrestrict {public static void Main (String [] String [] String [] {CollectionGenfoo <RARAYLIST> LISTFOO = null; listFoo = new CollectionGenfoo <RARAYLIST> (new ArrayList ()); CollectionGenfoo <? extiende la colección> listFoo1 = null; listFoo1 = new CollectionGenfoo <ArrayList> (new ArrayList ()); System.out.println ("Instanciación exitosa!");}} producción:
¡La instanciación fue exitosa!
Cinco métodos genéricos:
public class GenericFunction {public <t> void f (t x) {system.out.println (x.getClass (). getName ());} public static void main (string [] args) {genicFunction ea = new GenericFunction (); ea.f (""); ea.f (10); ea.f ('a'); ea.f (ea); producción:
java.lang.string
java.lang.integer
java.lang.caracter
Función genérica
----------------------------------------------------------------------------------------------------------------------------
Dylan presenta.
Resumir
Lo anterior es todo el contenido de este artículo sobre la explicación detallada de los ejemplos genéricos en Java, espero que sea útil para todos. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!