Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Zástupné znaky v typových argumentoch Javy

Zistite, čo možno čítať a zapisovať pomocou `?`, `? extends T` a `? super T` a ako tieto pravidlá v Java SE 21 platia pre zoznamy, polia, objekty `Class` a fronty referencií.

Verzia: Java SE 21

Syntax

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 typovom argumente ? zastupuje neznámy typ, ktorý spĺňa obmedzenia generickej deklarácie. Nie je to podmienený operátor ?:. List<?> má jeden neznámy typ prvkov, ktorý môže kompilátor zachytiť ako novú typovú premennú. Prvok možno čítať ako Object, ale nemožno priamo pridať hodnotu odlišnú od null. List<Object> má konkrétny typový argument Object a prijíma ľubovoľné objekty, ak podporuje vkladanie. Surový typ List obchádza niektoré kontroly generických typov.

Zoznamy sú invariantné vzhľadom na typový argument: List<Manager> nie je podtypom List<Employee>, ani keď Manager dedí od Employee. List<? extends Employee> prijíma zoznam s typom prvkov Employee alebo jeho podtypom. Prvky možno čítať ako Employee, ale nemožno priamo pridať ani Manager. List<? super Manager> prijíma zoznam s typom prvkov Manager alebo jeho nadtypom. Možno pridať Manager alebo jeho podtyp, ale bez pretypovania je pri čítaní zaručený iba Object. Ide o pravidlo PECS: producent extends, konzument super. Pridanie null prejde typovou kontrolou pri všetkých troch formách, ale zoznam môže null odmietnuť alebo nepodporovať vkladanie. Zástupný znak nerobí zoznam nemenným.

V copyFirst spája zoznamy deklarovaný typový parameter <T>: ? extends T umožňuje čítať hodnotu ako T a ? super T ju umožňuje zapísať. Ani jeden zástupný znak nedeklaruje T. Ak potrebujete opäť použiť ten istý neznámy typ prvkov List<?>, kompilátor môže odvodiť zachytený typ pre generickú pomocnú metódu s parametrom List<T>.

List<?> je jeden zoznam, zatiaľ čo List<?>[] je pole, ktorého pozície môžu obsahovať zoznamy s rôznymi typmi prvkov. Oba typy sú reifikovateľné: new List<?>[2] je platné, ale new List<String>[2] spôsobí chybu pri kompilácii. Kontrola pri zápise do poľa neoveruje typový argument zoznamu. Class<?> je objekt Class, ktorého reprezentovaný typ v signatúre nie je určený. typeName(Class<?> type) môže prijať String.class a zavolať getName() bez znalosti tohto argumentu.

Pri ReferenceQueue<Asset> metóda poll() nečaká: odoberie a vráti Reference<? extends Asset> alebo ihneď vráti null, ak je front prázdny. ? extends Asset obmedzuje typ odkazovaného objektu, nie typ samotnej referencie. Výsledok get() odlišný od null možno použiť ako Asset; vymazaná referencia vráti null. Vlastná trieda Asset prepisuje Object.toString() inštančnou metódou public String toString(). @Override zabezpečí kontrolu prepísania pri kompilácii; metóda sa vykoná aj pri volaní cez premennú typu Object.

Prí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ýsledok

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

`copyFirst` pridá jeden prvok do cieľa bez toho, aby ho odobral zo zdroja. `enqueue()` výslovne vymaže slabú referenciu a zaradí ju do frontu, pričom `reachabilityFence` dovtedy udrží `manager` silno dosiahnuteľný. Výstup nezávisí od načasovania zberu odpadu.

Súvisiace lekcie

  • Java · Lekcia 45 · Pokročilá · Verzia: 2
  • Java · Lekcia 58 · Základná · Verzia: 2
  • Java · Lekcia 59 · Základná · Verzia: 2
  • Java · Lekcia 33 · Stredne pokročilá · Verzia: 2
  • Java · Lekcia 34 · Stredne pokročilá · Verzia: 2
  • Java · Lekcia 36 · Stredne pokročilá · Verzia: 2
  • Java · Lekcia 37 · Stredne pokročilá · Verzia: 2

Zdroje