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
- Java Language Specification, Java SE 21, §4.5.1: Type Arguments of Parameterized Types
- Java Language Specification, Java SE 21, §4.7: Reifiable Types
- Java Language Specification, Java SE 21, §5.1.10: Capture Conversion
- Java Language Specification, Java SE 21, §15.10.1: Array Creation Expressions
- Java SE 21 API: List
- Java SE 21 API: Class and getName()
- Java SE 21 API: ReferenceQueue.poll()
- Java SE 21 API: Reference
- Java SE 21 API: WeakReference
- Java SE 21 API: Object.toString()
- Java SE 21 API: Override