Genericos en Java | Guia Completa
Genericos en Java
Guia Completa con Ejemplos Practicos
Java SE 5+ | Type Safety | Reutilizacion de Codigo
1. Que son los Genericos?
Los genericos (Generics) fueron introducidos en Java 5 como una caracteristica que permite
definir clases, interfaces y metodos con tipos como parametros. Esto proporciona una forma de
reutilizar el mismo codigo con diferentes tipos de datos, garantizando la seguridad de tipos en
tiempo de compilacion.
Antes de los genericos, se usaba el tipo Object para manejar estructuras de datos
genericas, lo que requeria casting explicito y podia causar ClassCastException en tiempo
de ejecucion.
Por que usar Genericos?
• Seguridad de tipos: Errores detectados en tiempo de compilacion, no en ejecucion.
• Eliminacion de casting: No es necesario hacer cast explicito al recuperar objetos.
• Reutilizacion de codigo: Una sola implementacion funciona para multiples tipos.
• Legibilidad: El codigo es mas claro y autodocumentado.
Sin Genericos (antes de Java 5)
// Sin genericos - riesgo de ClassCastException
List lista = new ArrayList();
[Link]("Hola");
[Link](42); // Se permite cualquier tipo
String s = (String) [Link](1); // ERROR en tiempo de ejecucion!
Java Generics Java Generics
Genericos en Java | Guia Completa
Con Genericos (Java 5+)
// Con genericos - seguridad en tiempo de compilacion
List<String> lista = new ArrayList<>();
[Link]("Hola");
// [Link](42); // ERROR en tiempo de COMPILACION
String s = [Link](0); // No se necesita casting
2. Clases Genericas
Una clase generica es una clase parametrizada con uno o mas tipos. El parametro de tipo se
especifica entre los simbolos < y > despues del nombre de la clase.
Sintaxis basica
public class Caja<T> {
private T contenido;
public Caja(T contenido) {
[Link] = contenido;
}
public T getContenido() {
return contenido;
}
public void setContenido(T contenido) {
[Link] = contenido;
}
}
Uso de la clase generica
Caja<String> cajaTexto = new Caja<>("Java");
Caja<Integer> cajaNumero = new Caja<>(100);
Caja<Double> cajaDecimal = new Caja<>(3.14);
[Link]([Link]()); // Java
[Link]([Link]()); // 100
Multiples parametros de tipo
public class Par<K, V> {
private K clave;
private V valor;
public Par(K clave, V valor) {
[Link] = clave;
[Link] = valor;
Java Generics Java Generics
Genericos en Java | Guia Completa
}
// getters y setters...
}
Par<String, Integer> edad = new Par<>("Ana", 30);
Par<Integer, Boolean> estado = new Par<>(1, true);
3. Metodos Genericos
Los metodos genericos son metodos que introducen sus propios parametros de tipo. Esto es
util cuando la genericidad aplica solo a un metodo especifico, no a toda la clase.
public class Utilidades {
// El parametro <T> va antes del tipo de retorno
public static <T> void imprimirArreglo(T[] arreglo) {
for (T elemento : arreglo) {
[Link](elemento + " ");
}
[Link]();
}
// Metodo que retorna el mayor de dos comparables
public static <T extends Comparable<T>> T mayor(T a, T b) {
return [Link](b) > 0 ? a : b;
}
}
// Uso
Integer[] nums = {1, 2, 3};
[Link](nums);
[Link]([Link](5, 8)); // 8
[Link]([Link]("Ana", "Bea")); // Bea
4. Interfaces Genericas
Las interfaces tambien pueden ser parametrizadas. Una clase que implemente una interfaz
generica debe proporcionar el tipo concreto o mantener la genericidad.
public interface Repositorio<T, ID> {
void guardar(T entidad);
T buscarPorId(ID id);
List<T> obtenerTodos();
void eliminar(ID id);
}
public class RepositorioUsuario implements Repositorio<Usuario, Long> {
@Override
public void guardar(Usuario usuario) { /* ... */ }
Java Generics Java Generics
Genericos en Java | Guia Completa
@Override
public Usuario buscarPorId(Long id) { /* ... */ return null; }
@Override
public List<Usuario> obtenerTodos() { /* ... */ return null; }
@Override
public void eliminar(Long id) { /* ... */ }
}
5. Wildcards (Comodines)
Los wildcards representan un tipo desconocido y se utilizan con el simbolo ?. Son
especialmente utiles al trabajar con colecciones cuando no se conoce o no importa el tipo
exacto.
Tipo de Wildcard Sintaxis Descripcion Uso comun
Wildcard ilimitado List<?> Acepta cualquier tipo Solo lectura generica
Upper bounded List<? extends T> Tipo T o subtipos de T Lectura (productor)
Lower bounded List<? super T> Tipo T o supertipos de Escritura (consumidor)
T
Ejemplos de Wildcards
// Wildcard ilimitado - puede leer pero no escribir con tipo especifico
public static void imprimirLista(List<?> lista) {
for (Object obj : lista) [Link](obj);
}
// Upper bounded - solo tipos Number o subtipos (Integer, Double...)
public static double sumar(List<? extends Number> lista) {
double suma = 0;
for (Number n : lista) suma += [Link]();
return suma;
}
// Lower bounded - puede agregar Integer o subtipos
public static void agregarNumeros(List<? super Integer> lista) {
[Link](1); [Link](2); [Link](3);
}
// Uso
List<Integer> enteros = [Link](1, 2, 3, 4, 5);
[Link](sumar(enteros)); // 15.0
Java Generics Java Generics
Genericos en Java | Guia Completa
6. Parametros de Tipo Acotados
Los parametros de tipo acotados permiten restringir los tipos que pueden usarse como
argumentos. Esto es util cuando se necesita que el tipo tenga ciertos metodos disponibles.
// T debe ser Number o una subclase de Number
public class Calculadora<T extends Number> {
private T valor;
public Calculadora(T valor) { [Link] = valor; }
public double obtenerDoble() {
return [Link]() * 2; // Podemos llamar metodos de
Number
}
}
Calculadora<Integer> c1 = new Calculadora<>(5); // OK
Calculadora<Double> c2 = new Calculadora<>(3.14); // OK
// Calculadora<String> c3 = ...; // ERROR de compilacion
// Multiples limites
public <T extends Comparable<T> & Cloneable> T clonarMayor(T a, T b) {
return [Link](b) >= 0 ? a : b;
}
7. Type Erasure (Borrado de Tipos)
El type erasure es el mecanismo por el cual Java implementa los genericos. El compilador
elimina toda la informacion de tipo generico durante la compilacion, reemplazando los
parametros de tipo por Object o por su limite superior.
Implicacion importante: Los genericos en Java son una caracteristica solo de tiempo de
compilacion. En tiempo de ejecucion, una List<String> y una List<Integer> son del mismo
tipo: List.
// Codigo fuente (antes del compilador)
public class Caja<T> {
private T valor;
public T getValor() { return valor; }
}
// Bytecode generado (despues de type erasure)
public class Caja {
private Object valor; // T -> Object
public Object getValor() { return valor; }
}
// Con bounded type
Java Generics Java Generics
Genericos en Java | Guia Completa
public class Calc<T extends Number> { ... }
// Se convierte en: T -> Number (no Object)
Consecuencias del Type Erasure
• No se puede instanciar un tipo generico: new T() esta prohibido.
• No se puede crear un arreglo de tipo generico: new T[] esta prohibido.
• No se puede usar instanceof con tipos genericos parametrizados.
• Dos instancias con diferente tipo tienen el mismo .getClass().
8. Colecciones Genericas en Java
El Java Collections Framework hace un uso extensivo de los genericos. A continuacion se
muestran las colecciones mas comunes con sus usos genericos.
Coleccion Declaracion generica Caracteristicas
ArrayList List<T> Lista dinamica ordenada,
permite duplicados
LinkedList List<T> / Deque<T> Lista doblemente enlazada,
eficiente en inserciones
HashSet Set<T> Conjunto sin duplicados, sin
orden garantizado
TreeSet Set<T extends Comparable> Conjunto ordenado
naturalmente
HashMap Map<K, V> Mapa clave-valor, sin orden
garantizado
TreeMap Map<K, V> Mapa ordenado por clave
PriorityQueue Queue<T> Cola con prioridad (heap)
Ejemplo practico con colecciones
// Lista generica
List<String> nombres = new ArrayList<>();
[Link]("Ana"); [Link]("Luis"); [Link]("Maria");
// Map generico
Map<String, Integer> edades = new HashMap<>();
[Link]("Ana", 25);
[Link]("Luis", 30);
// Iterar con tipos seguros
for ([Link]<String, Integer> entrada : [Link]()) {
[Link]([Link]() + ": " + [Link]());
Java Generics Java Generics
Genericos en Java | Guia Completa
// Streams con genericos (Java 8+)
List<Integer> numeros = [Link](1, 2, 3, 4, 5, 6);
List<Integer> pares = [Link]()
.filter(n -> n % 2 == 0)
.collect([Link]()); // [2, 4, 6]
9. Buenas Practicas y Convenciones
Convencion Significado Ejemplo de uso
T Type - Tipo generico class Caja<T>
E Element - Elemento de class Lista<E>
coleccion
K Key - Clave de un mapa class Mapa<K, V>
V Value - Valor de un mapa class Mapa<K, V>
N Number - Tipo numerico class Calc<N extends Number>
R Return - Tipo de retorno interface Funcion<T, R>
Principio PECS
PECS significa Producer Extends, Consumer Super. Es una regla para saber cuando usar
upper bounded o lower bounded wildcards:
• Producer Extends: Si el parametro produce datos para leer, usa <? extends T>.
• Consumer Super: Si el parametro consume datos para escribir, usa <? super T>.
// PECS en accion - copiar de src (productor) a dest (consumidor)
public static <T> void copiar(List<? extends T> src, List<? super T>
dest) {
for (T elemento : src) {
[Link](elemento);
}
}
List<Integer> origen = [Link](1, 2, 3);
List<Number> destino = new ArrayList<>();
copiar(origen, destino); // Funciona correctamente
10. Resumen
Los genericos son una herramienta fundamental en Java moderno. A continuacion se presenta
un resumen de los conceptos mas importantes:
Java Generics Java Generics
Genericos en Java | Guia Completa
• Clases genericas: Parametrizar la clase con uno o mas tipos (class Caja<T>).
• Metodos genericos: El tipo va antes del retorno (<T> void metodo(T arg)).
• Interfaces genericas: Igual que las clases (interface Repo<T, ID>).
• Wildcards: ? para tipo desconocido, ? extends T, ? super T.
• Bounded types: Restringen que tipos son validos (extends, super).
• Type Erasure: Los genericos son verificados en compilacion, no en ejecucion.
• PECS: Producer Extends, Consumer Super para wildcards.
Los genericos son la base de muchas APIs en Java como Collections, Stream API,
Optional, CompletableFuture y Spring Framework. Dominarlos es esencial para escribir
codigo Java limpio y seguro.
Java Generics Java Generics