Genéricos de Java
Genéricos de Java
En este tutorial, aprenderemos sobre Java Generics, cómo crear clases y métodos genéricos y sus ventajas con la ayuda de ejemplos.
Java Generics nos permite crear una sola clase, interfaz y método que se puede usar con diferentes tipos de datos (objetos).
Esto nos ayuda a reutilizar nuestro código.
Nota :Genéricos no funciona con tipos primitivos (int , float , char , etc.).
Clase de genéricos de Java
Podemos crear una clase que se puede utilizar con cualquier tipo de datos. Tal clase se conoce como Clase Genérica.
Así es como podemos crear una clase genérica en Java:
Ejemplo:crear una clase genérica
class Main {
public static void main(String[] args) {
// initialize generic class
// with Integer data
GenericsClass<Integer> intObj = new GenericsClass<>(5);
System.out.println("Generic Class returns: " + intObj.getData());
// initialize generic class
// with String data
GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
System.out.println("Generic Class returns: " + stringObj.getData());
}
}
// create a generics class
class GenericsClass<T> {
// variable of T type
private T data;
public GenericsClass(T data) {
this.data = data;
}
// method that return T type variable
public T getData() {
return this.data;
}
} Salida
Generic Class returns: 5 Generic Class returns: Java Programming
En el ejemplo anterior, hemos creado una clase genérica llamada GenericsClass . Esta clase se puede utilizar para trabajar con cualquier tipo de datos.
class GenericsClass<T> {...}
Aquí, T usado dentro del paréntesis angular <> indica el parámetro de tipo . Dentro del Main clase, hemos creado dos objetos de GenericsClass
- intObj - Aquí, el parámetro de tipo T se reemplaza por
Integer. Ahora, la GenericsClass funciona con datos enteros. - stringObj - Aquí, el parámetro de tipo T se reemplaza por
String. Ahora, la GenericsClass funciona con datos de cadena.
Método genérico de Java
Similar a la clase de genéricos, también podemos crear un método que se puede usar con cualquier tipo de datos. Esta clase se conoce como método genérico.
Así es como podemos crear una clase genérica en Java:
Ejemplo:crear un método genérico
class Main {
public static void main(String[] args) {
// initialize the class with Integer data
DemoClass demo = new DemoClass();
// generics method working with String
demo.<String>genericsMethod("Java Programming");
// generics method working with integer
demo.<Integer>genericsMethod(25);
}
}
class DemoClass {
// creae a generics method
public <T> void genericsMethod(T data) {
System.out.println("Generics Method:");
System.out.println("Data Passed: " + data);
}
} Salida
Generics Method: Data Passed: Java Programming Generics Method: Data Passed: 25
En el ejemplo anterior, hemos creado un método genérico llamado genericsMethod .
public <T> void genericMethod(T data) {...}
Aquí, el parámetro de tipo <T> se inserta después del modificador public y antes del tipo de retorno void .
Podemos llamar al método generics colocando el tipo real <String> y <Integer> dentro del corchete antes del nombre del método.
demo.<String>genericMethod("Java Programming");
demo.<Integer>genericMethod(25); Nota :Podemos llamar al método generics sin incluir el parámetro de tipo. Por ejemplo,
demo.genericsMethod("Java Programming"); En este caso, el compilador puede hacer coincidir el parámetro de tipo según el valor pasado al método.
Tipos delimitados
En general, el parámetro de tipo puede aceptar cualquier tipo de datos (excepto tipos primitivos).
Sin embargo, si queremos usar genéricos solo para algunos tipos específicos (como aceptar datos de tipos numéricos), entonces podemos usar tipos acotados.
En el caso de tipos enlazados, usamos el extends palabra clave. Por ejemplo,
<T extends A> Esto significa T solo puede aceptar datos que son subtipos de A .
Ejemplo:Tipos delimitados
class GenericsClass <T extends Number> {
public void display() {
System.out.println("This is a bounded type generics class.");
}
}
class Main {
public static void main(String[] args) {
// create an object of GenericsClass
GenericsClass<String> obj = new GenericsClass<>();
}
} En el ejemplo anterior, hemos creado una clase llamada GenericsClass. Observe la expresión, observe la expresión
<T extends Number>
Aquí, GenericsClass se crea con tipo acotado. Esto significa GenericsClass solo puede trabajar con tipos de datos que son hijos de Number (Integer , Double , etc.).
Sin embargo, hemos creado un objeto de la clase generics con String . En este caso, obtendremos el siguiente error.
GenericsClass<String> obj = new GenericsClass<>();
^
reason: inference variable T has incompatible bounds
equality constraints: String
lower bounds: Number
where T is a type-variable:
T extends Number declared in class GenericsClass Ventajas de los genéricos de Java
1. Reutilización de código
Con la ayuda de genéricos en Java, podemos escribir código que funcione con diferentes tipos de datos. Por ejemplo,
public <T> void genericsMethod(T data) {...} Aquí, hemos creado un método genérico. Este mismo método se puede utilizar para realizar operaciones en datos enteros, datos de cadena, etc.
2. Comprobación de tipos en tiempo de compilación
El parámetro de tipo de genéricos proporciona información sobre el tipo de datos utilizados en el código de genéricos. Por ejemplo,
// using Generics
GenericsClass<Integer> list = new GenericsClass<>();
Aquí, sabemos que GenericsClass está trabajando con Integer solo datos.
Ahora, si tratamos de pasar datos que no sean enteros a esta clase, el programa generará un error en tiempo de compilación.
3. Usado con Colecciones
El marco de las colecciones utiliza el concepto de genéricos en Java. Por ejemplo,
// creating a string type ArrayList
ArrayList<String> list1 = new ArrayList<>();
// creating a integer type ArrayList
ArrayList<Integer> list2 = new ArrayList<>(); En el ejemplo anterior, hemos usado la misma clase ArrayList para trabajar con diferentes tipos de datos.
Similar a ArrayList , otras colecciones (LinkedList , Queue , Maps , etc.) también son genéricos en Java.
Java