Types génériques en

À propos de Types génériques

Un type générique est une classe ou une interface générique qui est paramétrée par des types. Cela permet au compilateur de garantir la sûreté des types sur la classe ou l'interface.

Prenons cette interface Container non générique :

class Container {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Comme elle accepte et renvoie des types Object, elle fonctionne avec n'importe quel type non primitif. Cela a toutefois un coût, car une partie du code peut appeler get en attendant des Integer, pendant qu'une autre appelle set pour ajouter des String, ce qui provoque une exception à l'exécution.

Une classe générique et une interface générique ont le format suivant :

class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }

La section des paramètres de type, délimitée par des chevrons (<>), qui suit le nom de la classe ou de l'interface, précise les paramètres de type (aussi appelés variables de type) T1, T2, ..., et Tn. On peut les utiliser à l'intérieur du corps de la classe ou de l'interface pour obtenir la sûreté des types offerte par les génériques.

Voici la version générique de Container :

class Container<E> {
    private E object;

    public void set(E object) { this.object = object; }
    public E get() { return object; }
}

Au moment de le créer, il faut désormais déclarer le type qu'il contient, et le compilateur fera respecter cette contrainte :

// 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);