Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Wildcard negli argomenti di tipo in Java

Scopri cosa puoi leggere o scrivere con `?`, `? extends T` e `? super T` in Java SE 21 e come queste regole si applicano a liste, array, oggetti `Class` e code di riferimenti.

Versione: Java SE 21

Sintassi

Generic type arguments: G<?>, G<? extends T>, G<? super T> (T must already be in scope)
static <T> void copyFirst(List<? extends T> source, List<? super T> target)
List<? extends Employee> employees; List<? super Manager> destination;
Class<?> token = String.class;
List<?> list = List.of("tag"); List<?>[] lists = new List<?>[] { list };
Reference<? extends Asset> reference = queue.poll(); // queue has type ReferenceQueue<Asset>
Inside a class: @Override public String toString() { return "asset"; }

Come argomento di tipo, ? indica un tipo ignoto che rispetta i vincoli della dichiarazione generica. Non è l’operatore condizionale ?:. Una List<?> ha un unico tipo di elemento ignoto, che il compilatore può catturare come nuova variabile di tipo. Puoi leggere un elemento come Object, ma non aggiungere direttamente un valore diverso da null. List<Object> ha invece l’argomento di tipo specifico Object e accetta qualsiasi oggetto se supporta l’inserimento. Il tipo raw List aggira alcuni controlli sui tipi generici.

Le liste sono invarianti rispetto all’argomento di tipo: List<Manager> non è un sottotipo di List<Employee> neppure se Manager estende Employee. List<? extends Employee> accetta liste il cui tipo degli elementi è Employee o un sottotipo. Puoi leggere come Employee, ma non aggiungere direttamente nemmeno un Manager. List<? super Manager> accetta liste il cui tipo degli elementi è Manager o un supertipo. Puoi aggiungere un Manager o un sottotipo, ma senza cast puoi leggere solo con la garanzia di ottenere un Object. È la regola PECS: produttore extends, consumatore super. L’aggiunta di null supera il controllo dei tipi per tutte e tre le forme, ma la lista può rifiutare null o non supportare l’inserimento. Una wildcard non rende immutabile la lista.

In copyFirst, il parametro di tipo dichiarato <T> collega le liste: ? extends T permette di leggere un valore come T, mentre ? super T permette di scriverlo. Nessuna delle wildcard dichiara T. Per riutilizzare lo stesso tipo ignoto degli elementi di una List<?>, il compilatore può inferire il tipo catturato per un metodo ausiliario generico che riceve una List<T>.

List<?> è una lista, mentre List<?>[] è un array le cui posizioni possono contenere liste con tipi di elementi diversi. Entrambi i tipi sono reificabili: new List<?>[2] è valido, mentre new List<String>[2] causa un errore di compilazione. Il controllo di scrittura nell’array non verifica l’argomento di tipo della lista. Class<?> è un oggetto Class il cui tipo rappresentato non è specificato nella firma. typeName(Class<?> type) può ricevere String.class e chiamare getName() senza conoscere tale argomento.

Su una ReferenceQueue<Asset>, poll() non attende: estrae e restituisce una Reference<? extends Asset>, oppure restituisce subito null se la coda è vuota. ? extends Asset vincola il tipo dell’oggetto referenziato, non il tipo dell’oggetto riferimento. Un risultato non nullo di get() è utilizzabile come Asset; un riferimento azzerato restituisce null. La classe definita nell’esempio, Asset, esegue l’override di Object.toString() con il metodo di istanza public String toString(). @Override fa verificare l’override al compilatore; il metodo viene eseguito anche se invocato tramite una variabile di tipo Object.

Esempi

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

public class Main {
    static class Asset {
        @Override
        public String toString() {
            return "asset";
        }
    }

    static class Employee extends Asset {}
    static final class Manager extends Employee {}

    static <T> void copyFirst(List<? extends T> source, List<? super T> target) {
        if (!source.isEmpty()) {
            target.add(source.get(0));
        }
    }

    static String typeName(Class<?> type) {
        return type.getName();
    }

    public static void main(String[] args) {
        Manager manager = new Manager();
        List<Manager> managers = List.of(manager);
        List<? extends Employee> employees = managers;
        Object asset = employees.get(0);
        System.out.println(asset.toString());

        List<? super Manager> destination = new ArrayList<Employee>();
        copyFirst(managers, destination);
        System.out.println("copied: " + destination.size());

        List<?> tags = List.of("tag");
        List<?>[] groups = new List<?>[] { destination, tags };
        Object tag = groups[1].get(0);
        System.out.println(tag);
        System.out.println(typeName(String.class));

        ReferenceQueue<Asset> queue = new ReferenceQueue<>();
        System.out.println("empty: " + (queue.poll() == null));
        WeakReference<Manager> reference = new WeakReference<>(manager, queue);
        reference.enqueue();
        Reference.reachabilityFence(manager);
        Reference<? extends Asset> polled = queue.poll();
        System.out.println("same cleared reference: " + (polled == reference && polled.get() == null));
    }
}

Risultato

asset
copied: 1
tag
java.lang.String
empty: true
same cleared reference: true

`copyFirst` aggiunge un elemento alla destinazione senza rimuoverlo dall’origine. `enqueue()` azzera e accoda esplicitamente il riferimento debole, e `reachabilityFence` mantiene `manager` fortemente raggiungibile fino a quel momento. L’output non dipende da quando interviene il garbage collector.

Lezioni correlate

  • Java · Lezione 45 · Avanzato · Versione: 2
  • Java · Lezione 58 · Base · Versione: 2
  • Java · Lezione 59 · Base · Versione: 2
  • Java · Lezione 33 · Intermedio · Versione: 2
  • Java · Lezione 34 · Intermedio · Versione: 2
  • Java · Lezione 36 · Intermedio · Versione: 2
  • Java · Lezione 37 · Intermedio · Versione: 2

Fonti