CKTIS / Java
Carateres universais nos argumentos de tipo em Java
Aprende o que podes ler ou escrever com `?`, `? extends T` e `? super T` em Java SE 21, e como estas regras se aplicam a listas, arrays, objetos `Class` e filas de referências.
Versão: Java SE 21
Sintaxe
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"; }Como argumento de tipo, o caráter universal ? representa um tipo desconhecido que respeita os limites da declaração genérica. Não é o operador condicional ?:. Uma List<?> tem um único tipo de elemento desconhecido, que o compilador pode capturar numa nova variável de tipo. Podes ler um elemento como Object, mas não podes adicionar diretamente um valor diferente de null. List<Object> tem o argumento de tipo concreto Object e aceita quaisquer objetos se suportar a inserção. O tipo não parametrizado List contorna algumas verificações de tipos genéricos.
As listas são invariantes no argumento de tipo: List<Manager> não é um subtipo de List<Employee>, ainda que Manager derive de Employee. List<? extends Employee> aceita uma lista cujo tipo de elemento é Employee ou um subtipo. Podes ler como Employee, mas não adicionar diretamente nem sequer um Manager. List<? super Manager> aceita uma lista cujo tipo de elemento é Manager ou um supertipo. Podes adicionar um Manager ou um subtipo, mas, sem conversão explícita, só tens a garantia de ler como Object. É a regra PECS: produtor extends, consumidor super. Adicionar null passa a verificação de tipos nas três formas, mas a lista pode rejeitar null ou não suportar inserções. Um caráter universal não torna a lista imutável.
Em copyFirst, o parâmetro de tipo declarado <T> liga as duas listas: ? extends T permite ler um valor como T, e ? super T permite escrevê-lo. Nenhum dos carateres universais declara T. Para reutilizar o mesmo tipo de elemento desconhecido de uma List<?>, o compilador pode inferir o tipo capturado para um método auxiliar genérico que recebe uma List<T>.
List<?> é uma lista, enquanto List<?>[] é um array cujas posições podem conter listas com tipos de elemento diferentes. Ambos os tipos são reificáveis: new List<?>[2] é válido, mas new List<String>[2] causa um erro de compilação. A verificação ao guardar no array não verifica o argumento de tipo da lista. Class<?> é um objeto Class cujo tipo representado não está especificado na assinatura. typeName(Class<?> type) pode receber String.class e chamar getName() sem conhecer esse argumento.
Numa ReferenceQueue<Asset>, poll() não espera: retira e devolve uma Reference<? extends Asset> ou devolve de imediato null se a fila estiver vazia. ? extends Asset limita o tipo do objeto referenciado, não o do objeto referência. Podes usar um resultado não nulo de get() como Asset; uma referência limpa devolve null. A classe Asset, definida no exemplo, redefine Object.toString() com o método de instância public String toString(). @Override faz o compilador verificar a redefinição; o método é executado mesmo quando é chamado através de uma variável de tipo Object.
Exemplos
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));
}
}
Resultado
asset copied: 1 tag java.lang.String empty: true same cleared reference: true
`copyFirst` adiciona um elemento ao destino sem o retirar da origem. `enqueue()` limpa e coloca explicitamente a referência fraca na fila, e `reachabilityFence` mantém `manager` fortemente alcançável até esse momento. A saída não depende do momento em que a recolha de lixo ocorre.
Lições relacionadas
- Java · Lição 45 · Avançado · Versão: 2
- Java · Lição 58 · Básico · Versão: 2
- Java · Lição 59 · Básico · Versão: 2
- Java · Lição 33 · Intermédio · Versão: 2
- Java · Lição 34 · Intermédio · Versão: 2
- Java · Lição 36 · Intermédio · Versão: 2
- Java · Lição 37 · Intermédio · Versão: 2
Fontes
- 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