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

CKTIS / Java

Effacement de types et jetons de classe en Java

Après effacement, `ArrayList<String>` et `ArrayList<Integer>` ont la même classe à l’exécution. La réflexion peut néanmoins lire un argument de type dans la déclaration d’un champ.

Version : Java SE 21

Syntaxe

List<String> names = new ArrayList<>();
Class<String> stringToken = String.class;
Class<?> listToken = List.class;
Class<?> runtimeClass = names.getClass();
boolean isList = value instanceof List<?>; // value has static type Object
Type declaredType = field.getGenericType(); // field is a java.lang.reflect.Field

Le compilateur vérifie les types génériques avant l’effacement. ArrayList<String> et ArrayList<Integer> s’effacent tous deux en ArrayList. Une variable de type s’efface en l’effacement de sa première borne (Object si aucune borne n’est déclarée). Les objets créés directement avec ces deux paramétrages renvoient le même objet Class via getClass().

Un type réifiable est entièrement disponible à l’exécution. List<?> est réifiable, contrairement à List<String>. Si value est déclaré comme Object, value instanceof List<?> vérifie seulement si l’objet implémente List ; value instanceof List<String> ne compile pas. Java SE 21 autorise certains tests instanceof avec un type paramétré selon le type statique de l’opérande, mais ne vérifie pas les arguments de type effacés.

Un jeton de classe est un objet Class. Le littéral String.class a pour type Class<String>, et List.class représente l’interface List sans argument de type. Ni List<String>.class ni List<?>.class n’est un littéral valide : la réifiabilité ne suffit pas. Class.cast vérifie la compatibilité avec la classe ou l’interface représentée, pas le type des éléments d’une liste.

L’effacement ne supprime pas toute l’information générique. Pour un champ déclaré comme List<String>, l’attribut Signature du fichier de classe conserve le type déclaré. Field.getType() renvoie List.class, tandis que Field.getGenericType() renvoie un ParameterizedType qui permet de lire l’argument String. Cette information décrit la déclaration du champ, non l’objet qui y est actuellement stocké.

Exemples

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

public class TypeErasureDemo {
    private List<String> names = new ArrayList<>();

    public static void main(String[] args) throws NoSuchFieldException {
        var strings = new ArrayList<String>();
        var integers = new ArrayList<Integer>();
        System.out.println("Same runtime class: " + (strings.getClass() == integers.getClass()));
        System.out.println("Matches ArrayList.class: " + (strings.getClass() == ArrayList.class));

        Field field = TypeErasureDemo.class.getDeclaredField("names");
        System.out.println("Erased field type is List: " + (field.getType() == List.class));
        // This field is known to have a parameterized declaration.
        ParameterizedType declaredType = (ParameterizedType) field.getGenericType();
        System.out.println("Declared type argument is String: "
                + (declaredType.getActualTypeArguments()[0] == String.class));
    }
}

Résultat

Same runtime class: true
Matches ArrayList.class: true
Erased field type is List: true
Declared type argument is String: true

Les deux premiers résultats portent sur la classe des objets à l’exécution. Les deux derniers opposent le type effacé du champ à l’argument de type conservé dans sa déclaration.

Leçons associées

  • Java · Leçon 13 · Avancé · Version : 2

Sources