Evolução da linguagem Java (parte 5)

Neste artigo damos continuidade à nossa análise histórica sobre os recursos que cada versão do Java trouxe para tornar o código mais limpo e simples para o desenvolvedor.

Se você caiu de paraquedas aqui e ainda não leu a primeira parte, clique aqui.

Java 19 e 20

As versões Java 19 e 20 não trouxeram mudanças definitivas na forma de escrever código, mas apresentaram importantes recursos em preview que abririam o caminho para grandes transformações nas versões seguintes.

Java 21

O Java 21, lançado em setembro de 2023, esta versão trouxe finalmente recursos estáveis que mudaram a forma de escrever código no dia a dia.

Entre eles estão:

• Record Patterns
• Pattern Matching for switch

(As Virtual Threads também foram finalizadas — sem dúvida, a melhor parte desta versão. Elas merecem um artigo dedicado apenas a elas!)

🧩 Record Patterns

Os Record Patterns apresentados na versão do Java 19 e 20 e agora finalizado na 21, elas permitem desconstruir objetos record diretamente em variáveis.

record Point(int x, int y) {}

// Before 21
// pattern matching for instanceof
void printPoint(Object obj) {
    if (obj instanceof Point p) {
        System.out.println("x = " + p.x() + ", y = " + p.y());
    }
}

// With 21
// record pattern
void printPoint(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println("x = " + x + ", y = " + y);
    }
}

🧠 Pattern Matching for switch

O Pattern Matching for switch foi apresentado nas versões anteriores Java e agora finalizado no Java 21.

Agora o switch pode verificar tipos e extrair valores diretamente, eliminando a necessidade de múltiplos if/else com instanceof.

// Before
static String process(Object obj) {
    if (obj instanceof String s) {
        return "String com %d caracteres".formatted(s.length());
    } else if (obj instanceof Integer i) {
        return "Número: " + i;
    } else {
        return "Outro tipo";
    }
}

// With 21
static String process(Object obj) {
    return switch (obj) {
        case String s -> "String com %d caracteres".formatted(s.length());
        case Integer i -> "Número: " + i;
        case null -> "Valor nulo";
        default -> "Outro tipo";
    };
}

Java 22, 23 e 24

Com exceção do Java 23, que trouxe como recurso final o Markdown Documentation Comments no JavaDoc — permitindo documentar o código com Markdown de forma moderna — as versões 22, 23 e 24 tem evoluções em preview, voltadas à clareza da linguagem.

Com elas vieram os seguintes preview:

• Padrões com tipos primitivos em instanceof e switch
• Importações de módulo simplificadas (Module Import Declarations)
• Corpos de construtores flexíveis (Flexible Constructor Bodies)

Java 25

JDK 25 teve impacto direto na forma de escrever código mais simples e limpo. Em destaque temos o Compact Source Files and Instance Main Methods, Module Import Declarations, Corpos de construtores flexíveis

Compact Source Files and Instance Main Methods

Permite que programas Java simples ou protótipos sejam escritos com menos boilerplate, sem exigir a declaração explícita de

public class HelloWorld { 
  public static void main(String[] args) {
    System.out.println("Hello, Java!");
  } 
}

agora pode haver um arquivo com método void main() direto.

void main() {
    System.out.println("Hello, Java 25!");
}

Importações de módulo simplificadas (Module Import Declarations)

Simplifica a organização de código em projetos modulares.
Ele permite importar diretamente módulos inteiros, sem precisar listar dezenas de pacotes e classes.

Obs: Infelizmente não posso exemplificar e usar um recurso que nunca precisei usar. JPMS (Java Platform Module System) é um recurso opicional e coexiste com o modelo clássico classpath.

Corpos de construtores flexíveis

Torna os construtores mais flexíveis, permitindo executar código antes da chamada a super() ou this(), desde que esse código não use o objeto ainda não inicializado (ou seja, não acesse campos de instância nem invoque métodos de instância).

public class Produto extends Item {
    private final int preco;

    public Produto(int preco) {
        // ✅ Código permitido antes de super()
        if (preco < 0) {
            throw new IllegalArgumentException("Preço não pode ser negativo");
        }

        int precoFinal = Math.min(preco, 1000); // ajuste de valor
        super(precoFinal); // chamada pode vir depois

        this.preco = precoFinal;
    }
}

Conclusão:

A grande estrela deste artigo, sem dúvida, foi o Java 21, com novidades que realmente mudaram a forma de escrever código no dia a dia.

Meu segundo destaque vai para o Markdown Documentation Comments no JavaDoc, introduzido na versão 23.
Nos últimos anos, vimos o uso do JavaDoc diminuir, mas agora ele tem uma chance real de renascimento.
Podemos, inclusive, enxergar o JavaDoc como um par complementar ao OpenAPI/Swagger:

• O JavaDoc ficando responsável pela documentação interna, voltada para quem mantém o código.
• O OpenAPI/Swagger cuidando da documentação externa, voltada a times de front-end, QA e integradores.

Por fim, o recurso de Corpos de Construtores Flexíveis oferece uma casa mais natural para aquele código que precisa ser executado antes da inicialização completa de um objeto, tornando o construtor mais limpo e expressivo.