Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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