Tipos genéricos
Un tipo genérico es una clase o interfaz genérica que se parametriza con tipos.
Esto permite que el compilador garantice la seguridad de tipos en la clase o la interfaz.
Fíjate en esta interfaz Container, que no es genérica:
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Como acepta y devuelve tipos Object, funciona con cualquier tipo no primitivo.
Sin embargo, esto tiene un precio, porque puede que una parte del código llame a get esperando Integer y otra llame a set añadiendo String, lo que da lugar a una excepción en tiempo de ejecución.
Una clase genérica y una interfaz genérica tienen el siguiente formato:
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
La sección de parámetros de tipo, delimitada por corchetes angulares (<>) y situada a continuación del nombre de la clase o de la interfaz, especifica los parámetros de tipo (también llamados variables de tipo) T1, T2, ..., y Tn.
Se pueden usar dentro del cuerpo de la clase o la interfaz para conseguir seguridad de tipos genéricos.
Aquí tienes la versión genérica de Container:
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Al crearlo, ahora tenemos que declarar qué tipo contiene y el compilador hará cumplir esa restricción:
// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);
List
Las List son la colección de secuencias ordenadas de Java.
A diferencia de los arrays, una List puede crecer de tamaño para albergar cualquier número de elementos.
Una implementación estándar es ArrayList, que se apoya en un array que se puede redimensionar.
Otra implementación estándar es la clase LinkedList, que se apoya en una lista doblemente enlazada.
Las List pueden estar vacías o contener cualquier número de elementos (incluidos los duplicados).
Las List son una interfaz genérica tipada para indicar qué tipo de objetos pueden contener.
Por ejemplo:
List<String> emptyListOfStrings = List.of();
List<Integer> singleInteger = List.of(1);
List<Boolean> threeBooleans = List.of(true, false, true);
List<Object> listWithMultipleTypes = List.of("hello", 1, true);
Las List tienen varios métodos útiles para añadir, eliminar, obtener y comprobar si un elemento está presente:
List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));
int startingSize = vowels.size(); // 7
vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']
char a = vowels.get(0); // 'a'
boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']
boolean hasI = vowels.contains('i'); // true (still have one more left)
Ejercicio de aprendizaje
