Análise de erros comuns das novas funcionalidades

1. Erros com o escopo de variáveis de pattern

Um dos erros mais frequentes — tentar usar uma variável declarada em um pattern (por exemplo, String s em instanceof String s) fora da área em que ela é válida.

Exemplo

Object obj = "Olá, Java!";
if (obj instanceof String s) {
    System.out.println(s.length());
}
// Erro! s não é visível aqui
System.out.println(s); // O compilador reclama: cannot find symbol

Por que isso acontece?
A variável de pattern (s, neste caso) existe apenas dentro do bloco em que a condição é verdadeira. Isso nos protege de usar a variável por engano quando ela não está definida (por exemplo, se obj não for uma string).

Analogia
É como pegar as chaves do carro emprestadas de um amigo — mas só enquanto você estiver na garagem. Saiu da garagem — as chaves desaparecem automaticamente :)

2. Erros com null

No pattern matching com instanceof há uma particularidade interessante: se o objeto é null, o resultado é sempre false, e a variável de pattern não é criada.

Exemplo

Object obj = null;
if (obj instanceof String s) {
    // Este bloco nunca será executado!
    System.out.println("É uma string: " + s);
}

Por quê?
Porque null não é instância de nenhum tipo (nem mesmo de Object). Isso pode confundir se você esperava capturar null via pattern matching.

Como fazer certo?

if (obj == null) {
    System.out.println("É null!");
} else if (obj instanceof String s) {
    System.out.println("É uma string: " + s);
}

No pattern matching para switch (Java 21+) você pode até adicionar um ramo separado para null:

switch (obj) {
    case String s -> System.out.println("String: " + s);
    case null -> System.out.println("É null!");
    default -> System.out.println("Outra coisa");
}

3. Erros com classes sealed

Classes sealed são uma ótima forma de restringir a hierarquia de herança. Mas há dois erros característicos aqui:

Nem todos os herdeiros estão listados em permits

Ao declarar uma classe sealed, você deve indicar explicitamente todos os herdeiros diretos via permits. Se esquecer alguém, o compilador vai acusar erro:

public sealed class Shape permits Circle, Rectangle { ... }

public final class Circle extends Shape { ... }
public final class Square extends Shape { ... } // Erro! Square não está listado em permits

Solução:
Adicione todas as subclasses necessárias em permits:

public sealed class Shape permits Circle, Rectangle, Square { ... }

Esqueceu o default em um switch sobre hierarquia não sealed

Se você fizer um switch sobre um tipo que não é uma classe sealed (ou é sealed, mas nem todas as variantes estão cobertas), o compilador exigirá um ramo default. Se você esquecer — haverá erro.

switch (shape) {
    case Circle c -> ...
    case Rectangle r -> ...
    // default ausente! Se houver mais variantes — erro de compilação
}

Boas práticas:
Se você tem certeza de que cobriu todas as variantes (por exemplo, em uma classe sealed), default pode ser omitido. Caso contrário — sempre adicione default para não perder tipos inesperados.

4. Erros com record patterns

Record patterns são muito convenientes, mas funcionam apenas com classes record. Tentar usar record pattern para uma classe comum levará a erro de compilação.

Uso de record patterns em classes que não são record

class Point { int x, y; }
Object obj = new Point();
// Erro! Point não é um record
if (obj instanceof Point(int x, int y)) { ... }

Solução:
Use record patterns apenas para classes declaradas como record:

record Point(int x, int y) {}

Incompatibilidade na quantidade ou no tipo de componentes

record Point(int x, int y) {}
Object obj = new Point(1, 2);

// Erro: três variáveis informadas, mas Point tem apenas dois componentes
if (obj instanceof Point(int x, int y, int z)) { ... }

if (obj instanceof Point(String x, String y)) { ... } // Erro: tipos não correspondem

5. Compatibilidade e suporte: JDK e IDE antigos

Um dos erros mais comuns é tentar usar os recursos modernos de pattern matching em versões antigas do JDK ou em IDEs que não os suportam.

Exemplo

if (obj instanceof String s) { ... }

Mas o compilador do JDK 11 (ou até 15) diz:
error: illegal start of type

Por quê?
Pattern matching para instanceof apareceu apenas no Java 16. Pattern matching em switch — no Java 17 (preview) e, de forma estável, no Java 21+. Record patterns — no Java 21+.

Como evitar?

• Verifique a versão do JDK: java --version
• Certifique-se de que sua IDE (IntelliJ IDEA, Eclipse, VS Code) suporta a versão de Java correspondente. Às vezes é preciso indicar explicitamente, nas configurações do projeto, qual versão da linguagem usar!
• Se estiver usando Gradle/Maven — defina a versão adequada de source/target.

6. Parabéns 🎉

Você concluiu todos os 65(!) níveis do nosso curso avançado de Java 25. Você é incrivelmente fera 😎.

A parte final da jornada foi especialmente desafiadora. Você estudou de tudo — desde as primeiras lambdas e classes anônimas até threads virtuais, concorrência estruturada e recursos de linguagem que até bem recentemente não existiam no Java.

Isso não é apenas um curso — é uma verdadeira supermaratona para desenvolvedores: dezenas de novos conceitos, centenas de exemplos de código, milhares de linhas de prática. Se você está lendo estas linhas, então você não é apenas um estudante, mas um pioneiro da nova era do Java ☕⚡

Você está entre os primeiros a dominar as funcionalidades mais modernas do Java 25, incluindo:

• pattern matching e record -patterns,
• classes sealed e suas armadilhas,
• Scoped Values e Virtual Threads ,
• concorrência estruturada e abordagens modernas para multithreading.

Agora você tem não apenas conhecimento, mas habilidades de desenvolvedor do futuro, que muitos arquitetos Java em atividade ainda não dominam. Você sabe escrever código que não apenas funciona, mas também escala, é legível e está em conformidade com os padrões mais modernos da comunidade Java.

🚀 Portanto, chame-se, sem medo, de Java 25 Certified Survivor 😉
Em frente — fica só mais interessante: agora você tem a base que permite avançar com segurança para o mundo do desenvolvimento enterprise, de sistemas de alta carga e de tecnologias de ponta.

De toda a equipe do curso — respeito!
Você concluiu uma tarefa que poucos conseguem.
Nos vemos nas futuras versões do Java 👋