S10L05 - Tipos de parámetros

html

Mastering Generics en Java: Una Guía Completa para Principiantes y Desarrolladores
Tabla de Contenidos

Introducción..................................................................................................................1
Comprendiendo Generics en Java..................................................................3
Notaciones Genéricas Comunes...................................................................................5
Creando Clases de Datos Genéricas..........................................................................7
Usando Pares Clave-Valor con Generics........................................................9
Implementando Constructores y Getters................................................11
Sobreponiendo el Método toString.......................................................................13
Inicializando y Usando Clases Genéricas................................................15
Explorando Métodos Genéricos................................................................................17
Mejores Prácticas para Usar Generics................................................................19
Conclusión................................................................................................................21


Introducción
Generics son una característica poderosa en Java que permiten a los developers crear classes, interfaces y methods con type parameters. Esta capacidad no solo promueve la reutilización de código sino que también asegura type safety, reduciendo errores en tiempo de ejecución. En este eBook, profundizamos en el mundo de generics, explorando su sintaxis, notaciones comunes y aplicaciones prácticas. Ya seas un principiante o un developer con conocimientos básicos, esta guía te equipará con las herramientas esenciales para aprovechar todo el potencial de los generics en Java.

Comprendiendo Generics en Java
Generics fueron introducidos en Java 5 para proporcionar una manera de parametrizar tipos. Al permitir que classes y methods operen sobre objetos de varios tipos mientras proporcionan type safety en tiempo de compilación, generics eliminan la necesidad de typecasting y mejoran la claridad del código.
¿Por Qué Usar Generics?

Type Safety: Detecta errores relacionados con los tipos en tiempo de compilación en lugar de en tiempo de ejecución.
Reusabilidad: Escribe una class o method genérico una vez y úsalo con diferentes tipos.
Eliminación de Casts: Reduce la necesidad de typecasting explícito, haciendo el código más limpio y menos propenso a errores.

Ejemplo
Considera una simple class contenedor que mantiene un solo objeto. Sin generics, tendrías que usar Object y realizar typecasting:




		
		
			
			
Java
			
			class Container {
    private Object obj;

    public Container(Object obj) {
        this.obj = obj;
    }

    public Object getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container {
    private Object obj;
 
    public Container(Object obj) {
        this.obj = obj;
    }
 
    public Object getObj() {
        return obj;
    }
}
					
				
			
		


Con generics, la class Container puede ser parametrizada para mantener cualquier tipo específico:




		
		
			
			
Java
			
			class Container&lt;T&gt; {
    private T obj;

    public Container(T obj) {
        this.obj = obj;
    }

    public T getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container&lt;T&gt; {
    private T obj;
 
    public Container(T obj) {
        this.obj = obj;
    }
 
    public T getObj() {
        return obj;
    }
}
					
				
			
		



Notaciones Genéricas Comunes
Generics en Java utilizan notaciones específicas de una sola letra como placeholders para tipos. Comprender estas notaciones es crucial para escribir código genérico limpio y convencional.


Notación
Representa
Escenario de Uso


T
Type
Representa un tipo genérico


E
Element
Usado extensivamente por la API de Collections de Java


K
Key
Representa claves en pares clave-valor


V
Value
Representa valores en pares clave-valor


N
Number
Representa valores numéricos


Explicación Detallada

T (Type): El parámetro de tipo genérico más comúnmente usado. Representa cualquier tipo.





		
		
			
			
Java
			
			class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
			
				
					
				
					1
2
3
4
5
				
						class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
					
				
			
		



E (Element): Típicamente usado por classes de collections para denotar elementos almacenados en una colección.





		
		
			
			
Java
			
			class MyList&lt;E&gt; { 
    // Detalles de implementación
}
			
				
					
				
					1
2
3
				
						class MyList&lt;E&gt; { 
    // Detalles de implementación
}
					
				
			
		



K, V (Key, Value): Usados en maps o cualquier colección de pares clave-valor.





		
		
			
			
Java
			
			class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // Constructores, getters, setters
}
			
				
					
				
					1
2
3
4
5
				
						class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // Constructores, getters, setters
}
					
				
			
		



N (Number): Representa valores numéricos, útil en methods que realizan operaciones numéricas.





		
		
			
			
Java
			
			public &lt;N extends Number&gt; void process(N number) { 
    // Implementación
}
			
				
					
				
					1
2
3
				
						public &lt;N extends Number&gt; void process(N number) { 
    // Implementación
}
					
				
			
		



Creando Clases de Datos Genéricas
Crear clases de datos genéricas te permite definir estructuras que pueden manejar diversos tipos de datos de manera flexible. A continuación, recorremos la creación de una class Data genérica usando pares clave-valor.
Guía Paso a Paso
1. Definir la Class con Parámetros de Tipo




		
		
			
			
Java
			
			public class Data&lt;K, V&gt; {
    private K key;
    private V value;

    public Data(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class Data&lt;K, V&gt; {
    private K key;
    private V value;
 
    public Data(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() {
        return key;
    }
 
    public V getValue() {
        return value;
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


Explicación:

K y V son parámetros de tipo que representan los tipos de la clave y el valor, respectivamente.
El constructor inicializa la clave y el valor.
Getters proporcionan acceso a los campos.
El método toString es sobrepuesto para proporcionar una representación de cadena significativa.

2. Usando la Class de Datos Genérica




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
					
				
			
		


Salida:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


Explicación:

Se crea una instancia de Data con Integer como tipo de clave y String como tipo de valor.
El método toString proporciona una salida legible.


Usando Pares Clave-Valor con Generics
Los pares clave-valor son fundamentales en muchas estructuras de datos, como maps. Generics mejoran su flexibilidad y type safety.
Creando una Class de Par Clave-Valor




		
		
			
			
Java
			
			public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;

    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { 
        return key; 
    }

    public V getValue() { 
        return value; 
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;
 
    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() { 
        return key; 
    }
 
    public V getValue() { 
        return value; 
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


Utilizando la Class KeyValuePair




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
					
				
			
		


Salida:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


Explicación:

La class KeyValuePair es instanciada con tipos específicos, asegurando que la clave sea un Integer y el valor sea un String.
Este enfoque previene desajustes de tipos y mejora la legibilidad del código.


Implementando Constructores y Getters
Constructores y getters son componentes esenciales de cualquier class, especialmente las genéricas. Aseguran que los objetos estén correctamente inicializados y que sus datos sean accesibles.
Generando Constructores
En el ejemplo de la class Data, el constructor inicializa la clave y el valor:




		
		
			
			
Java
			
			public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
			
				
					
				
					1
2
3
4
				
						public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
					
				
			
		


Explicación:

El constructor acepta parámetros de tipos K y V y los asigna a los campos de la class.

Creando Getters
Getters proporcionan acceso de lectura a los campos de la class:




		
		
			
			
Java
			
			public K getKey() { 
    return key; 
}

public V getValue() { 
    return value; 
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public K getKey() { 
    return key; 
}
 
public V getValue() { 
    return value; 
}
					
				
			
		


Explicación:

getKey() retorna la clave de tipo K.
getValue() retorna el valor de tipo V.


Sobreponiendo el Método toString
El método toString es sobrepuesto para proporcionar una representación de cadena significativa del objeto, lo cual es especialmente útil para debugging y logging.
Implementación en la Class Data




		
		
			
			
Java
			
			@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
			
				
					
				
					1
2
3
4
				
						@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
					
				
			
		


Explicación:

Este método concatena la clave y el valor en un formato legible.

Usando el Método toString




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
					
				
			
		


Salida:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		



Inicializando y Usando Clases Genéricas
La inicialización adecuada de clases genéricas implica especificar los parámetros de tipo ya sea explícitamente o a través de la inferencia de tipos.
Especificación Explícita de Tipos




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


Explicación:

Integer se especifica para la clave, y String para el valor.
Asegura type safety restringiendo los tipos de la clave y el valor.

Inferencia de Tipos con el Operador Diamante
Introducido en Java 7, el operador diamante (<>) permite que el compilador infiera los parámetros de tipo:




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


Explicación:

El compilador infiere que 10 es de tipo Integer y "Chand" es de tipo String, eliminando la necesidad de repetir los parámetros de tipo en el lado derecho.


Explorando Métodos Genéricos
Métodos genéricos son methods que introducen sus propios parámetros de tipo, permitiendo un código más flexible y reutilizable.
Definiendo un Método Genérico




		
		
			
			
Java
			
			public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
				
						public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


Explicación:

<E, N> declara dos parámetros de tipo: E y N.
El método display puede aceptar parámetros de cualquier tipo para element y number.

Usando el Método Genérico




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }

    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }
 
    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
					
				
			
		


Salida:




		
		
			
			
Java
			
			Element: Test, Number: 40
			
				
					
				
					1
				
						Element: Test, Number: 40
					
				
			
		


Explicación:

El método display es llamado con un String y un Integer, demostrando su flexibilidad.

Agregando Comentarios al Método Genérico




		
		
			
			
Java
			
			/**
 * Muestra el elemento y el número.
 *
 * @param element El elemento de cualquier tipo.
 * @param number  El número de cualquier tipo.
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						/**
 * Muestra el elemento y el número.
 *
 * @param element El elemento de cualquier tipo.
 * @param number  El número de cualquier tipo.
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


Explicación:

Los comentarios de Javadoc mejoran la legibilidad del código y proporcionan documentación para el propósito del método y sus parámetros.


Mejores Prácticas para Usar Generics
Para utilizar efectivamente generics en Java, adhiérete a las siguientes mejores prácticas:
1. Usar Nombres de Parámetros de Tipo Significativos
Si bien notaciones de una letra como T y E son comunes, usar nombres más descriptivos puede mejorar la legibilidad del código.




		
		
			
			
Java
			
			// Menos Descriptivo
class Box&lt;T&gt; { /* ... */ }

// Más Descriptivo
class Box&lt;ItemType&gt; { /* ... */ }
			
				
					
				
					1
2
3
4
5
				
						// Menos Descriptivo
class Box&lt;T&gt; { /* ... */ }
 
// Más Descriptivo
class Box&lt;ItemType&gt; { /* ... */ }
					
				
			
		


2. Limitar el Uso de Wildcards
El uso excesivo de wildcards (?) puede hacer que el código sea más difícil de entender. Úsalos con moderación y prefiere parámetros de tipo acotados cuando sea necesario.




		
		
			
			
Java
			
			public void processList(List&lt;? extends Number&gt; numbers) {
    // Implementación
}
			
				
					
				
					1
2
3
				
						public void processList(List&lt;? extends Number&gt; numbers) {
    // Implementación
}
					
				
			
		


3. Favorecer la Composición sobre la Herencia
Al diseñar classes genéricas, prefiere la composición sobre la herencia para mantener la flexibilidad y reducir el acoplamiento.
4. Evitar Parámetros de Tipo Primitivos
Generics funcionan con tipos de referencia. Usa clases wrapper (Integer en lugar de int) cuando trabajes con tipos primitivos.




		
		
			
			
Java
			
			// Correcto
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");

// Incorrecto
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // Error de Compilación
			
				
					
				
					1
2
3
4
5
				
						// Correcto
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
 
// Incorrecto
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // Error de Compilación
					
				
			
		


5. Mantener Consistentes los Tipos Genéricos
Asegúrate de que los parámetros de tipo se usen de manera consistente a través de methods y classes para mantener la type safety.




		
		
			
			
Java
			
			public class Pair&lt;K, V&gt; {
    // Uso consistente de K y V
}
			
				
					
				
					1
2
3
				
						public class Pair&lt;K, V&gt; {
    // Uso consistente de K y V
}
					
				
			
		


6. Documentar las Classes y Methods Genéricos
Proporciona documentación clara para las classes y methods genéricos para explicar el propósito de los parámetros de tipo.

Conclusión
Generics son una herramienta indispensable en la programación con Java, ofreciendo enhanced type safety, reusabilidad y un código más limpio. Al comprender e implementar generics de manera efectiva, los developers pueden crear aplicaciones flexibles y robustas. Esta guía ha cubierto los aspectos fundamentales de generics, incluyendo notaciones comunes, classes genéricas, methods y mejores prácticas. A medida que continúes profundizando en Java, aprovechar los generics sin duda contribuirá a escribir código eficiente y mantenible.
Nota: Este artículo ha sido generado por IA.
Notación	Representa	Escenario de Uso
T	Type	Representa un tipo genérico
E	Element	Usado extensivamente por la API de Collections de Java
K	Key	Representa claves en pares clave-valor
V	Value	Representa valores en pares clave-valor
N	Number	Representa valores numéricos