Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Effacement des types génériques en Java

Java vérifie les arguments de type à la compilation, mais `ArrayList<String>` et `ArrayList<Integer>` n’ont pas de classes distinctes à l’exécution. Cela explique les restrictions sur les tableaux et `instanceof`.

Version : Java SE 21

Syntaxe

Type erasure is a compiler rule, not a Java keyword. In specification notation, |X| means the erasure of X: |List<String>| = List; |T| = Object for an unbounded T; |T| = Number for T extends Number & Comparable<T>; |T[]| = |T|[].

L’effacement des types génériques est une règle de compilation, pas un mot-clé. Le compilateur tient compte des arguments de type lors de ses vérifications. List<String> s’efface en List. Une variable de type T s’efface en l’effacement de sa borne la plus à gauche, ou en Object si aucune borne n’est déclarée. Le compilateur insère les conversions de type nécessaires et peut générer des méthodes ponts pour préserver la redéfinition des méthodes.

ArrayList<String> et ArrayList<Integer> sont des types distincts dans le code source, mais getClass() renvoie le même objet Class pour les instances créées ici. La réflexion peut lire les signatures génériques des déclarations, mais getClass() seul ne révèle pas l’argument de type d’une instance. On ne peut pas non plus surcharger m(List<String>) et m(List<Integer>) dans une même classe : les deux signatures s’effacent en m(List).

new List<String>[2] provoque une erreur de compilation, car List<String> n’est pas entièrement disponible à l’exécution : ce type n’est pas réifiable. Lors d’une écriture dans un tableau, la JVM vérifie le type de composant, mais elle ne peut pas vérifier l’argument String. new List<?>[2] est autorisé : List<?> est réifiable et n’impose aucun type particulier aux éléments de la liste.

Si value est de type statique Object, value instanceof List<String> ne compile pas, car la conversion de type correspondante serait non vérifiée. value instanceof List<?> vérifie que l’objet implémente List, pas le contenu de la liste. Depuis Java SE 16, certains tests avec des arguments de type concrets sont permis : si x est déclaré List<Integer>, x instanceof ArrayList<Integer> est valide, car la conversion ne serait pas non vérifiée. À l’exécution, le test porte sur ArrayList, pas sur l’argument Integer ni sur le contenu.

Exemples

import java.util.ArrayList;
import java.util.List;

public class TypeErasureDemo {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        ArrayList<Integer> numbers = new ArrayList<>();
        System.out.println(strings.getClass() == numbers.getClass());

        Object value = strings;
        System.out.println(value instanceof List<?>);
        // boolean invalidTest = value instanceof List<String>;

        List<Integer> x = numbers;
        System.out.println(x instanceof ArrayList<Integer>);

        List<?>[] lists = new List<?>[2];
        lists[0] = strings;
        lists[1] = numbers;
        System.out.println(lists.length);
        // List<String>[] invalidArray = new List<String>[2];
    }
}

Résultat

true
true
true
2

Les trois premières lignes valent `true` : même classe, correspondance avec `List<?>`, puis avec `ArrayList<Integer>` compte tenu du type statique. `2` est la longueur du tableau. Décommentez séparément chaque instruction invalide pour observer son erreur de compilation.

Leçons associées

  • Java · Leçon 58 · Débutant · Version : 2
  • Java · Leçon 36 · Intermédiaire · Version : 2

Sources