Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Symbole wieloznaczne w typach generycznych Javy

Dowiedz się, co można odczytać i zapisać przez `?`, `? extends T` i `? super T` oraz jak te reguły działają dla list, tablic, tokenów klas i kolejek referencji w Java SE 21.

Wersja: Java SE 21

Składnia

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

W argumencie typu zapis ? oznacza nieznany typ spełniający ograniczenia deklaracji. Nie jest to operator warunkowy ?:. List<?> to lista o jednym nieznanym typie elementów, który kompilator może przechwycić jako pomocniczą zmienną typu. get daje wartość typu Object, ale nie można po prostu dodać wartości innej niż null. List<Object> ma konkretny argument Object i pozwala dodawać dowolne obiekty, jeśli obsługuje dodawanie. Surowy typ List pomija część kontroli typów generycznych.

Typy List są niezmiennicze względem argumentu: List<Manager> nie jest podtypem List<Employee>, nawet jeśli Manager dziedziczy po Employee. List<? extends Employee> przyjmuje listę o typie elementów Employee lub jego podtypie. Można czytać jako Employee, ale nie można po prostu dodać nawet Manager. List<? super Manager> przyjmuje listę o typie elementów Manager lub jego nadtypie. Można dodać Manager lub jego podtyp, ale odczyt bez rzutowania daje tylko Object. Jest to reguła PECS: producent — extends, konsument — super. null przechodzi kontrolę typów we wszystkich tych wariantach, lecz lista może go odrzucać lub nie obsługiwać modyfikacji. Symbol wieloznaczny sam nie czyni listy niemodyfikowalną.

W copyFirst parametr <T> nazywa typ łączący odczyt i zapis: ? extends T pozwala odczytać wartość jako T, a ? super T pozwala ją zapisać. Symbole wieloznaczne nie deklarują T. Gdy trzeba użyć tego samego nieznanego typu z List<?>, kompilator może wywnioskować przechwycony typ jako parametr metody pomocniczej przyjmującej List<T>.

List<?> to jedna lista, a List<?>[] to tablica, której pozycje mogą zawierać listy o różnych typach elementów. Oba typy są reifikowalne: new List<?>[2] jest poprawne, a new List<String>[2] nie przechodzi kompilacji. Kontrola zapisu w tablicy nie sprawdza argumentu typu elementów listy. Class<?> oznacza obiekt Class reprezentujący typ nieokreślony w sygnaturze. Dlatego typeName(Class<?> type) przyjmuje String.class i może wywołać getName() bez znajomości tego argumentu.

Dla ReferenceQueue<Asset> metoda poll() nie czeka: usuwa i zwraca Reference<? extends Asset> lub od razu zwraca null, jeśli kolejka jest pusta. ? extends Asset ogranicza typ obiektu wskazywanego przez referencję, a nie typ samej referencji. Jeśli get() zwróci wartość inną niż null, można jej użyć jako Asset; wyczyszczona referencja daje null. W przykładzie własna klasa Asset przesłania Object.toString() metodą public String toString(). @Override pozwala kompilatorowi wykryć pomyłkę w deklaracji; właściwa implementacja działa nawet przy wywołaniu przez zmienną typu Object.

Przykłady

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

Wynik

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

`copyFirst` przenosi jeden element do listy docelowej przez dodanie go, bez usuwania ze źródła. `enqueue()` jawnie czyści i kolejkuje słabą referencję, a `reachabilityFence` utrzymuje `manager` silnie osiągalnym do tego momentu. Wynik nie zależy od czasu działania odśmiecacza.

Powiązane lekcje

  • Java · Lekcja 45 · Zaawansowany · Wersja: 2
  • Java · Lekcja 58 · Podstawowy · Wersja: 2
  • Java · Lekcja 59 · Podstawowy · Wersja: 2
  • Java · Lekcja 33 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 34 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 36 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 37 · Średniozaawansowany · Wersja: 2

Źródła