Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Cancellazione dei tipi generici in Java

Java controlla gli argomenti di tipo in compilazione, ma `ArrayList<String>` e `ArrayList<Integer>` non hanno classi distinte a runtime. Questa distinzione spiega i vincoli sugli array e su `instanceof`.

Versione: Java SE 21

Sintassi

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|[].

La cancellazione dei tipi generici è una regola di compilazione, non una parola chiave. Il compilatore usa gli argomenti di tipo per controllare il codice. La cancellazione di List<String> dà List. Una variabile di tipo T viene sostituita dalla cancellazione del suo limite più a sinistra, oppure da Object se non è dichiarato alcun limite. Il compilatore inserisce i cast necessari e può generare metodi ponte per preservare l’override.

ArrayList<String> e ArrayList<Integer> sono tipi distinti nel sorgente, ma getClass() restituisce lo stesso oggetto Class per le istanze create qui. La riflessione può leggere le firme generiche delle dichiarazioni, ma getClass() da solo non rivela l’argomento di tipo di un’istanza. Non si possono neppure dichiarare gli overload m(List<String>) e m(List<Integer>) nella stessa classe: entrambe le firme diventano m(List).

new List<String>[2] causa un errore di compilazione perché List<String> non è pienamente disponibile a runtime: non è reificabile. Quando si scrive in un array, la JVM verifica il tipo dei componenti, ma non può verificare l’argomento String. new List<?>[2] è consentito: List<?> è reificabile e non impone un tipo specifico agli elementi della lista.

Se value ha tipo statico Object, value instanceof List<String> non compila perché il cast corrispondente non sarebbe verificabile. value instanceof List<?> verifica che l’oggetto implementi List, non il contenuto della lista. Da Java SE 16 sono ammessi alcuni test con argomenti di tipo concreti: se x è dichiarato come List<Integer>, x instanceof ArrayList<Integer> è valido perché il cast non richiederebbe una conversione non verificata. A runtime il test verifica che l’oggetto sia un ArrayList, non l’argomento Integer né il contenuto.

Esempi

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];
    }
}

Risultato

true
true
true
2

Le prime tre righe mostrano `true`: stessa classe, corrispondenza con `List<?>` e corrispondenza con `ArrayList<Integer>` dato il tipo statico. `2` è la lunghezza dell’array. Rimuovi il commento da ciascuna istruzione non valida separatamente per vedere il relativo errore di compilazione.

Lezioni correlate

  • Java · Lezione 58 · Base · Versione: 2
  • Java · Lezione 36 · Intermedio · Versione: 2

Fonti