Java Generics
Java permite que los programadores puedan crear clases, interfaces y métodos en los que el tipo de datos sobre los que operan se especifica como parámetro. Es decir, de tipos parametrizados.A estos se les denomina genéricos. Por ejemplo, una clase que maneja estos parámetros se denomina clase genérica, igualmente será con un método o interfaz.
Un método genérico debe ser declarado dentro de una clase o interfaz genérica. Para ello, empleamos la siguiente sintaxis:
// Clase genérica
public class Generico<T>
//Interfaz genérica
public interface Generico<T,E>
La ventaja del código que emplea estos métodos es que funcionará automáticamente con el tipo de datos pasados a su parámetro de tipo.
// Instanciación de la clase genérica
Generico<String> gen = new Generico<>();
// En este caso el tipo de dato es un String
Estos algoritmos son muy útiles para y se emplean muchísimo en las bibliotecas internas de Java como en las Colecciones o métodos de ordenamiento rápido.
Clase genérica simple- Código
Declaramos el tipo genérico T y un atributo de ese tipo llamado "atributo"
package clases;
public class Generico<T> {
private T atributo;
public Generico(T atributo) {
this.atributo = atributo;
}
public String getClase() {
return String.format("Clase: %s", this.atributo.getClass().getName());
}
public String getAtributo() {
return String.format("Contenido: %s", this.atributo.toString());
}
}Prueba y resultado
Al crear objetos de estas clases genéricas podemos emplear 3 formas:
- Indicar dentro de la sintaxis diamante el tipo
- Usar el tipo desconocido ?, el constructor recibe el tipo de parámetro
- Obviar el tipo, el constructor recibe el parámetro y usa su tipo.
package test;
import clases.ContenedorGenerico;
import clases.Generico;
import clases.Operador;
public class Test {
public static void main(String[] args) {
Generico<String> gen1 = new Generico<>("Hola");
System.out.println(gen1.getClase());
System.out.println(gen1.getAtributo());
Generico<?> gen2 = new Generico(45d);
System.out.println(gen2.getClase());
System.out.println(gen2.getAtributo());
Generico gen3 = new Generico(true);
System.out.println(gen3.getClase());
System.out.println(gen3.getAtributo());
}
}Clase: java.lang.String Contenido: Hola Clase: java.lang.Double Contenido: 45.0 Clase: java.lang.Boolean Contenido: true
Clase genérica con varios parámetros - Código
Podemos indicar más de un tipo genérico, estos van separados por comas.
package clases;
import java.util.HashMap;
import java.util.Map;
public class ContenedorGenerico<E,F> {
private Map<E, F> contenedor;
public ContenedorGenerico() {
this.contenedor = new HashMap<>();
}
public void agregar(E clave, F valor) {
this.contenedor.put(clave, valor);
}
public Map<E, F> getContenedor() {
return this.contenedor;
}
}Prueba y resultado
Las colecciones emplean internamente las clases y métodos genéricos.
package test;
import clases.ContenedorGenerico;
import clases.Generico;
import clases.Operador;
public class Test {
public static void main(String[] args) {
ContenedorGenerico<Integer,String> contenedor = new ContenedorGenerico<>();
contenedor.agregar(12, "doce");
contenedor.agregar(11, "once");
contenedor.agregar(10, "diez");
contenedor.getContenedor().forEach((k,v)->{
System.out.println("Clave: "+k);
System.out.println("Valor: "+v);
});
}
}Clave: 10 Valor: diez Clave: 11 Valor: once Clave: 12 Valor: doce
Clase genérica con parámetros limitados - Código
Para limitar el tipo de datos que se pueden recibir se utiliza la palabra reservada "extends" y luego la superclase. Por ejemplo, el siguiente código muestra una clase que solo permite tener parámetros de tipo numéricos.
package clases;
public class Operador<A extends Number, B extends Number> {
A valorA;
B valorB;
public Operador(A valorA, B valorB) {
this.valorA = valorA;
this.valorB = valorB;
}
public Double getSuma() {
return this.valorA.doubleValue() + this.valorB.doubleValue();
}
public Double getProducto() {
return this.valorA.doubleValue() * this.valorB.doubleValue();
}
}Prueba y resultado
package test;
import clases.ContenedorGenerico;
import clases.Generico;
import clases.Operador;
public class Test {
public static void main(String[] args) {
Operador op1 = new Operador(4, 5);
System.out.println("Suma: " + op1.getSuma());
System.out.println("Producto: " + op1.getProducto());
Operador op2 = new Operador(4.6, 5);
System.out.println("Suma: " + op2.getSuma());
System.out.println("Producto: " + op2.getProducto());
Operador op3 = new Operador(2.5, 1.65);
System.out.println("Suma: " + op3.getSuma());
System.out.println("Producto: " + op3.getProducto());
}
}Suma: 9.0 Producto: 20.0 Suma: 9.6 Producto: 23.0 Suma: 4.15 Producto: 4.125
