Genéricos medio tipos parametrizados . La idea es permitir que el tipo (Entero, Cadena,… etc., y tipos definidos por el usuario) sea un parámetro para métodos, clases e interfaces. Usando Generics, es posible crear clases que funcionen con diferentes tipos de datos. Una entidad como clase, interfaz o método que opera en un tipo parametrizado es una entidad genérica.
¿Por qué genéricos?
El Objeto es la superclase de todas las demás clases y la referencia a objeto puede hacer referencia a cualquier objeto. Estas características carecen de seguridad de tipos. Los genéricos añaden ese tipo de característica de seguridad. Discutiremos ese tipo de característica de seguridad en ejemplos posteriores.
Los genéricos en Java son similares a las plantillas en C++. Por ejemplo, clases como HashSet, ArrayList, HashMap, etc. utilizan muy bien los genéricos. Existen algunas diferencias fundamentales entre los dos enfoques de los tipos genéricos.
Tipos de genéricos de Java
Método genérico: El método genérico de Java toma un parámetro y devuelve algún valor después de realizar una tarea. Es exactamente como una función normal; sin embargo, un método genérico tiene parámetros de tipo que se citan por tipo real. Esto permite utilizar el método genérico de una manera más general. El compilador se encarga del tipo de seguridad que permite a los programadores codificar fácilmente, ya que no tienen que realizar conversiones de tipos individuales largas.
Clases genéricas: Una clase genérica se implementa exactamente igual que una clase no genérica. La única diferencia es que contiene una sección de parámetro de tipo. Puede haber más de un tipo de parámetro, separados por una coma. Las clases que aceptan uno o más parámetros se conocen como clases parametrizadas o tipos parametrizados.
Clase genérica
Al igual que C++, lo utilizamos para especificar tipos de parámetros en la creación de clases genéricas. Para crear objetos de una clase genérica, utilizamos la siguiente sintaxis.
// To create an instance of generic class BaseType obj = new BaseType ()>
Nota: En tipo de parámetro no podemos usar primitivas como 'int', 'char' o 'double'.
Java
// Java program to show working of user defined> // Generic classes> // We use to specify Parameter type> class> Test {> >// An object of type T is declared> >T obj;> >Test(T obj) {>this>.obj = obj; }>// constructor> >public> T getObject() {>return> this>.obj; }> }> // Driver class to test above> class> Main {> >public> static> void> main(String[] args)> >{> >// instance of Integer type> >Test iObj =>new> Test(>15>);> >System.out.println(iObj.getObject());> >// instance of String type> >Test sObj> >=>new> Test(>'GeeksForGeeks'>);> >System.out.println(sObj.getObject());> >}> }> |
>
>Producción
15 GeeksForGeeks>
También podemos pasar múltiples parámetros de tipo en clases genéricas.
Java
fecha y hora mecanografiadas
// Java program to show multiple> // type parameters in Java Generics> // We use to specify Parameter type> class> Test> {> >T obj1;>// An object of type T> >U obj2;>// An object of type U> >// constructor> >Test(T obj1, U obj2)> >{> >this>.obj1 = obj1;> >this>.obj2 = obj2;> >}> >// To print objects of T and U> >public> void> print()> >{> >System.out.println(obj1);> >System.out.println(obj2);> >}> }> // Driver class to test above> class> Main> {> >public> static> void> main (String[] args)> >{> >Test obj => >new> Test(>'GfG'>,>15>);> >obj.print();> >}> }> |
identificadores válidos de java
>
>Producción
GfG 15>
Funciones genéricas:
También podemos escribir funciones genéricas que se puedan llamar con diferentes tipos de argumentos según el tipo de argumentos pasados al método genérico. El compilador maneja cada método.
Java
// Java program to show working of user defined> // Generic functions> class> Test {> >// A Generic method example> >static> >void> genericDisplay(T element)> >{> >System.out.println(element.getClass().getName()> >+>' = '> + element);> >}> >// Driver method> >public> static> void> main(String[] args)> >{> >// Calling generic method with Integer argument> >genericDisplay(>11>);> >// Calling generic method with String argument> >genericDisplay(>'GeeksForGeeks'>);> >// Calling generic method with double argument> >genericDisplay(>1.0>);> >}> }> |
>
>Producción
java.lang.Integer = 11 java.lang.String = GeeksForGeeks java.lang.Double = 1.0>
Los genéricos funcionan sólo con tipos de referencia:
Cuando declaramos una instancia de un tipo genérico, el argumento de tipo pasado al parámetro de tipo debe ser un tipo de referencia. No podemos utilizar tipos de datos primitivos como En t , carbonizarse.
Test obj = new Test(20);>
La línea anterior genera un error en tiempo de compilación que se puede resolver usando contenedores de tipos para encapsular un tipo primitivo.
Pero las matrices de tipos primitivos se pueden pasar al parámetro de tipo porque las matrices son tipos de referencia.
ArrayList a = new ArrayList();>
Los tipos genéricos difieren según sus argumentos de tipo:
Considere el siguiente código Java.
Java
// Java program to show working> // of user-defined Generic classes> // We use to specify Parameter type> class> Test {> >// An object of type T is declared> >T obj;> >Test(T obj) {>this>.obj = obj; }>// constructor> >public> T getObject() {>return> this>.obj; }> }> // Driver class to test above> class> Main {> >public> static> void> main(String[] args)> >{> >// instance of Integer type> >Test iObj =>new> Test(>15>);> >System.out.println(iObj.getObject());> >// instance of String type> >Test sObj> >=>new> Test(>'GeeksForGeeks'>);> >System.out.println(sObj.getObject());> >iObj = sObj;>// This results an error> >}> }> |
>
>
Producción:
error: incompatible types: Test cannot be converted to Test>
Aunque iObj y sObj son de tipo Prueba, son referencias a tipos diferentes porque sus parámetros de tipo difieren. Los genéricos añaden seguridad de tipos a través de esto y evitan errores.
Escriba parámetros en genéricos de Java
Las convenciones de nomenclatura de los parámetros de tipo son importantes para aprender a fondo los genéricos. Los parámetros de tipo comunes son los siguientes:
Python de búsqueda binaria
- T – Tipo
- E – Elemento
- K – Clave
- N – Número
- V – Valor
Ventajas de los genéricos:
Los programas que utilizan genéricos tienen muchas ventajas sobre el código no genérico.
1. Reutilización de código: Podemos escribir un método/clase/interfaz una vez y usarlo para cualquier tipo que queramos.
2. Tipo de seguridad: Los genéricos hacen que aparezcan errores en tiempo de compilación que en tiempo de ejecución (siempre es mejor conocer los problemas en su código en tiempo de compilación en lugar de hacer que su código falle en tiempo de ejecución). Supongamos que desea crear un ArrayList que almacene los nombres de los estudiantes, y si por error el programador agrega un objeto entero en lugar de una cadena, el compilador lo permite. Pero, cuando recuperamos estos datos de ArrayList, causa problemas en tiempo de ejecución.
Java
// Java program to demonstrate that NOT using> // generics can cause run time exceptions> import> java.util.*;> class> Test> {> >public> static> void> main(String[] args)> >{> >// Creatinga an ArrayList without any type specified> >ArrayList al =>new> ArrayList();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >al.add(>10>);>// Compiler allows this> >String s1 = (String)al.get(>0>);> >String s2 = (String)al.get(>1>);> >// Causes Runtime Exception> >String s3 = (String)al.get(>2>);> >}> }> |
>
ordenar una lista de matrices java
>
Producción :
Exception in thread 'main' java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at Test.main(Test.java:19)>
¿Cómo resuelven los genéricos este problema?
Al definir ArrayList, podemos especificar que esta lista solo pueda tomar objetos String.
Java
// Using Java Generics converts run time exceptions into> // compile time exception.> import> java.util.*;> class> Test> {> >public> static> void> main(String[] args)> >{> >// Creating a an ArrayList with String specified> >ArrayList al =>new> ArrayList ();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >// Now Compiler doesn't allow this> >al.add(>10>);> >String s1 = (String)al.get(>0>);> >String s2 = (String)al.get(>1>);> >String s3 = (String)al.get(>2>);> >}> }> |
>
>
Producción:
15: error: no suitable method found for add(int) al.add(10); ^>
3. No se necesita fundición de tipo individual: Si no usamos genéricos, entonces, en el ejemplo anterior, cada vez que recuperamos datos de ArrayList, tenemos que encasillarlos. Encasillar en cada operación de recuperación es un gran dolor de cabeza. Si ya sabemos que nuestra lista solo contiene datos de cadenas, no necesitamos encasillarla cada vez.
Java
// We don't need to typecast individual members of ArrayList> import> java.util.*;> class> Test {> >public> static> void> main(String[] args)> >{> >// Creating a an ArrayList with String specified> >ArrayList al =>new> ArrayList();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >// Typecasting is not needed> >String s1 = al.get(>0>);> >String s2 = al.get(>1>);> >}> }> |
>
>
4. Los genéricos promueven la reutilización del código: Con la ayuda de genéricos en Java, podemos escribir código que funcione con diferentes tipos de datos. Por ejemplo,
Digamos que queremos ordenar los elementos de la matriz de varios tipos de datos como int, char, String, etc.
Básicamente necesitaremos diferentes funciones para diferentes tipos de datos.
Para simplificar, usaremos la clasificación por burbujas.
Pero al usar genéricos, podemos lograr la función de reutilización del código.
Java
public> class> GFG {> >public> static> void> main(String[] args)> >{> >Integer[] a = {>100>,>22>,>58>,>41>,>6>,>50> };> >Character[] c = {>'v'>,>'g'>,>'a'>,>'c'>,>'x'>,>'d'>,>'t'> };> >String[] s = {>'Virat'>,>'Rohit'>,>'Abhinay'>,>'Chandu'>,>'Sam'>,>'Bharat'>,>'Kalam'> };> >System.out.print(>'Sorted Integer array : '>);> >sort_generics(a);> >System.out.print(>'Sorted Character array : '>);> >sort_generics(c);> >System.out.print(>'Sorted String array : '>);> >sort_generics(s);> > >}> >public> static> extends Comparable>void sort_generics(T[] a) { //Como comparamos los tipos de datos no primitivos //necesitamos usar la clase Comparable //Lógica de clasificación de burbujas for (int i = 0; i 1; i++) { for (int j = 0; j 1; j++) { si (a[j].compareTo(a[j + 1])> 0) { intercambiar(j, j + 1, a); } } } // Imprimiendo los elementos después de ordenar for (T i : a) { System.out.print(i + ', '); } System.out.println(); } intercambio de vacío estático público (int i, int j, T[] a) { T t = a[i]; a[i] = a[j]; a[j] = t; } }> |
>
regexp_like en mysql
>Producción
Sorted Integer array : 6, 22, 41, 50, 58, 100, Sorted Character array : a, c, d, g, t, v, x, Sorted String array : Abhinay, Bharat, Chandu, Kalam, Rohit, Sam, Virat,>
Aquí, hemos creado un método genérico. Este mismo método se puede utilizar para realizar operaciones con datos enteros, datos de cadenas, etc.
5. Implementación de algoritmos genéricos: Al usar genéricos, podemos implementar algoritmos que funcionan en diferentes tipos de objetos y, al mismo tiempo, también son seguros.