Synaptic IT

Generics es un servicio que se añadió a Java en el 2004 como parte de Java 5.

La característica de generics en Java permite a las aplicaciones crear clases y objetos que pueden operar sobre cualquier tipo definido. Los programadores pueden ahora hacer uso de esta característica para un código mucho mejor. No hay necesidad de un casteo cuando se trata de objetos de una colección.

Generics permite hacer un programa bien formado y evitar el tipo de errores inesperados que podrían ocurrir en tiempo de ejecución.

A continuación veremos en un ejemplo sencillo, como generics enriquece nuestro código.

Antes de Java generics:

1
2
3
4

List dictionary = new ArrayList();
dictionary.add("A");
dictionary.add("B");
String s = ((String)dictionary.get(0) + (String)dictionary.get(1));

Despues de Java generics:

1
2
3
4

List<String> dictionary = new ArrayList<String>();
dictionary.add("A");
dictionary.add("B");
String s = dictionary.get(0) + dictionary.get(1);

Sin generics, el tipo de parámetro se omite, pero se tiene que castear explícitamente cuando se extrae un elemento de la lista.

Clases Genéricas

En una clase genérica, el tipo de parámetro(T y U) aparece en la cabecera al declarar la clase, pero no en el constructor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Pair<T, U> {
	private final T first;
	private final U second;
	public Pair(T first, U second) { 
		this.first = first;
		this.second = second;
	}
	public T getFirst() {
		return first;
	}
	public U getSecond() {
		return second;
	}
}

Sin embargo, el tipo de los parámetros se pasan al constructor siempre que se lo invoca:

1
2
3

Pair<String, Integer> pair = new Pair<String, Integer>("one", 2);
String s = pair.getFirst();
Integer i = pair.getSecond();

Métodos Genéricos

Aquí hay un método que acepta un arreglo de cualquier tipo y la convierte a una lista:

1
2
3
4
5
6
7

public class ListUtil {
	public static <T> List<T> toList(T[] arr) {
		List<T> list = new ArrayList<T>();
		for (T element : arr) list.add(element);
		return list;
	}
}

El método estático toList convierte un array de tipo T [] en una lista de tipo List<T>. El método puede ser invocado asi:

1
2

List<Integer> ints = ListUtil.toList(new Integer[] {1, 2, 3});
List<String> dictionary = ListUtil.toList(new String[] {"A", "B", "C"});

Comodines

A veces nos gustaría que las listas se comportarsen más como arrays, no queremos aceptar sólo una lista con elementos de un mismo tipo, sino también una lista con los elementos de un determinadto subtipo. Con este fin, utilizamos comodines.

Para especificar el límite superior de un elemento genérico, se usa la palabra clave extends, lo que indica que el tipo genérico es un subtipo de la delimitación de clase. Entonces así una List<? extends Number> significa que dada la lista, esta contiene algunos objetos de tipo desconocido que se extienden de la clase Number. Por ejemplo, la lista podría ser una List<Float>, List<Integer> o de List<Number>.

Para especificar el límite inferior de un elemento genérico, se usa la palabra clave super, lo que indica que el tipo genérico es un supertipo de la delimitación de clase. Así que una List<? super Number> podría ser una List<Number> o List<Object>. Cualquier elemento de tipo Number puede añadirse a la lista, ya que se garantiza que sea un tipo válido para almacenar en la lista.

1
2
3
4
5

public interface Collection<E> {
	...
	public boolean addAll(Collection<? extends E> c);
	...
}

En el ejemplo, creamos una lista vacia de numeros, le agregamos una lista de enteros y luego una lista de dobles.

1
2
3
4
5

List<Number> nums = new ArrayList<Number>();
List<Integer> ints = Arrays.asList(1, 2);
List<Double> dbls = Arrays.asList(4.64, 8.11);
nums.addAll(ints);
nums.addAll(dbls);

Múltiples Limites

En raras situaciones, puede ser conveniente contar con múltiples límites, a continuación muestramos cómo hacerlo.
En el siguiente ejemplo, utilizamos tres interfaces: Human, Martian y Speaker.

1
2
3
4
5
6

...
public static <S extends Human & Speaker, 
			T extends Martian & Speaker>
	void transform(S hs, T ms) 
{
...

This entry was posted on Miércoles, Marzo 12th, 2008 at 8:25 and is filed under Java. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.