Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Zástupné znaky v typových argumentech Javy

Zjistěte, co lze číst a zapisovat pomocí `?`, `? extends T` a `? super T` a jak tato pravidla v Java SE 21 platí pro seznamy, pole, objekty `Class` a fronty referencí.

Verze: Java SE 21

Syntaxe

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

V typovém argumentu zastupuje ? neznámý typ, který splňuje omezení generické deklarace. Nejde o podmíněný operátor ?:. List<?> má jeden neznámý typ prvků, který může překladač zachytit jako novou typovou proměnnou. Prvek lze číst jako Object, ale nelze přímo přidat hodnotu odlišnou od null. List<Object> má konkrétní typový argument Object a přijímá libovolné objekty, pokud podporuje vkládání. Surový typ List obchází některé kontroly generických typů.

Seznamy jsou vzhledem k typovému argumentu invariantní: List<Manager> není podtypem List<Employee>, ani když Manager dědí z Employee. List<? extends Employee> přijímá seznam s typem prvků Employee nebo jeho podtypem. Prvek lze číst jako Employee, ale nelze přímo přidat ani Manager. List<? super Manager> přijímá seznam s typem prvků Manager nebo jeho nadtypem. Lze přidat Manager či jeho podtyp, ale při čtení bez přetypování je zaručen pouze Object. To je pravidlo PECS: producent extends, konzument super. Přidání null projde typovou kontrolou u všech tří tvarů, ale seznam může null odmítnout nebo vkládání nepodporovat. Zástupný znak sám o sobě nezajišťuje neměnnost seznamu.

V copyFirst propojuje seznamy deklarovaný typový parametr <T>: ? extends T dovoluje číst hodnotu jako T a ? super T ji dovoluje zapsat. Žádný z těchto zápisů nedeklaruje T. Potřebujete-li znovu použít tentýž neznámý typ prvků List<?>, překladač může odvodit zachycený typ pro generickou pomocnou metodu s parametrem List<T>.

List<?> je jeden seznam, zatímco List<?>[] je pole, jehož pozice mohou obsahovat seznamy s různými typy prvků. Oba typy jsou reifikovatelné: new List<?>[2] je platné, ale new List<String>[2] způsobí chybu při překladu. Kontrola při zápisu do pole neověřuje typový argument seznamu. Class<?> je objekt Class, jehož reprezentovaný typ není v signatuře určen. typeName(Class<?> type) může přijmout String.class a zavolat getName() bez znalosti tohoto argumentu.

U ReferenceQueue<Asset> metoda poll() nečeká: odebere a vrátí Reference<? extends Asset>, nebo okamžitě vrátí null, je-li fronta prázdná. ? extends Asset omezuje typ odkazovaného objektu, nikoli typ samotné reference. Výsledek get() odlišný od null lze použít jako Asset; vymazaná reference vrátí null. Vlastní třída Asset přepisuje Object.toString() instanční metodou public String toString(). @Override přiměje překladač ověřit přepsání; metoda se provede i při volání přes proměnnou typu Object.

Příklady

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

Výsledek

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

`copyFirst` přidá jeden prvek do cílového seznamu, aniž ho odebere ze zdroje. `enqueue()` výslovně vymaže slabou referenci a zařadí ji do fronty; `reachabilityFence` do té doby udržuje `manager` silně dosažitelný. Výstup nezávisí na okamžiku spuštění garbage collectoru.

Související lekce

  • Java · Lekce 45 · Pokročilá · Verze: 2
  • Java · Lekce 58 · Základní · Verze: 2
  • Java · Lekce 59 · Základní · Verze: 2
  • Java · Lekce 33 · Středně pokročilá · Verze: 2
  • Java · Lekce 34 · Středně pokročilá · Verze: 2
  • Java · Lekce 36 · Středně pokročilá · Verze: 2
  • Java · Lekce 37 · Středně pokročilá · Verze: 2

Zdroje