Generic class com static

❗ Uma classe genérica NÃO pode usar seu tipo genérico dentro de um método static. Exemplo

public class Caixa<T> {
  private T valor;

  public void setValor(T valor) {
    this.valor = valor;
  }

  public static void imprimeValor(T valor) { // ❌ ERRO
    System.out.println(valor);
  }
}

💥 Isso não compila!

• Porque o método static pertence à classe como um todo, não a uma instância.
• Mas T só é conhecido quando a classe é instanciada, ou seja, em tempo de execução.
• Portanto, um método static não tem acesso ao parâmetro genérico da classe.

✅ Como resolver? Declarando o tipo genérico no próprio método.

Você pode usar generics dentro de um método static, mas deve declarar o tipo genérico localmente, usando public static <T>:

public class Util {

  public static <T> void imprimeValor(T valor) {
    System.out.println(valor);
  }
}

Agora sim! O compilador entende que T é um tipo genérico local ao método.

💡 Exemplo prático:

public class Util {

  public static <T> void imprimirArray(T[] array) {
    for (T elemento : array) {
      System.out.println(elemento);
    }
  }

  public static <T> T primeiroElemento(List<T> lista) {
    return lista.isEmpty() ? null : lista.get(0);
  }
}

Você pode usar assim:

String[] nomes = { "Ana", "Carlos", "Beatriz" };
Util.imprimirArray(nomes); // imprime cada nome

List<Integer> numeros = Arrays.asList(1, 2, 3);
// retorna 1
Integer primeiro = Util.primeiroElemento(numeros); 

Diferença entre o retorno <T> T e apenas <T> void
A parte <T> antes do void declara que o método é genérico e que T será usado dentro dele.

O método não retorna nada (void), apenas imprime.

O <T> serve apenas para indicar ao compilador que esse método usará um tipo genérico chamado T.

Quando <T> T isso diz para o compilador que o primeiro <T> irá usar Generics e que o tipo do retorno é o segundo T ou seja na hora da instância List<Integer> o <T> apenas diz: “vou usar um tipo Genérico” o segundo T indica o Tipo que no exemplo é Integer.

🔄 E se a classe não for genérica?

Sem problemas! Métodos genéricos static funcionam em classes que não são genéricas:

public class Ferramentas {

  public static <X> void mostrar(X x) {
    System.out.println("Valor: " + x);
  }
}

Chamada:

Ferramentas.mostrar("texto"); // Valor: texto
Ferramentas.mostrar(42);      // Valor: 42

🧨 Pegadinhas comuns:

1. Tentar usar o tipo genérico da classe em métodos static:
   • ❌ Não funciona, porque o tipo só existe em instâncias.
2. Esquecer de declarar <T> antes do retorno:
   • Errado: public static T metodo(...)
   • Correto: public static <T> T metodo(...)
3. Achar que só classes genéricas podem ter métodos genéricos:
   • ❌ Errado. Métodos genéricos podem estar em qualquer classe.

🚀 Resumo