Java Moderno: 5 Práticas que Transformam Seu Código em Profissional

💡 “Não é sobre saber tudo. É sobre saber o que evitar.”

Java é uma linguagem madura, robusta e amplamente usada — mas isso não significa que todo código Java seja bom.

Muitos desenvolvedores ainda escrevem como se estivessem em 2005, ignorando os avanços das versões recentes como Java 17, 21 e 23.

Neste artigo, vamos mostrar como aplicar recursos modernos para evitar os erros mais comuns e escrever código limpo, performático e profissional.

❌ 1. Verbosidade desnecessária em estruturas de controle

Iniciantes costumam criar longas cadeias de if/else, tornando o código difícil de ler e manter:

if (status.equals("ATIVO")) {
  mensagem = "Usuário ativo";
} else if (status.equals("INATIVO")) {
  mensagem = "Usuário inativo";
} else {
  mensagem = "Status desconhecido";
}

✅ A solução moderna — Switch Expressions

Desde o Java 14 (e refinado até o Java 21), o switch virou uma expressão mais segura e concisa:

String mensagem = switch (status) {
  case "ATIVO" -> "Usuário ativo";
  case "INATIVO" -> "Usuário inativo";
  default -> "Status desconhecido";
};

💬 Switch agora é uma expressão: mais conciso, mais seguro e mais legível.

❌ 2. Classes Mutáveis e Sem Encapsulamento

Classes com atributos públicos quebram o encapsulamento e tornam o código frágil:

public class Produto {
  public String nome;
  public double preco;
}

✅ A solução moderna — Records

Com o record (Java 16+), você cria classes imutáveis e concisas:

public record Produto(String nome, double preco) {}

🔒 Menos código, mais segurança. Records são imutáveis por padrão.

❌ 3. Captura Genérica de Exceções

Capturar Exception esconde erros específicos e dificulta o rastreamento:

try {
  executar();
} catch (Exception e) {
  System.out.println("Erro: " + e.getMessage());
}

✅ A solução moderna — Multi-Catch e Pattern Matching

O Java moderno permite capturar exceções específicas de forma elegante:

try {
  processar();
} catch (IOException | SQLException e) {
  System.out.println("Erro específico: " + e.getMessage());
}

🧠 Cada exceção merece atenção — isso facilita a depuração e melhora a legibilidade.

❌ 4. Threads Manuais para Tarefas Simples

Criar threads manualmente é pesado e difícil de escalar:

new Thread(() -> executar()).start();

✅ A solução moderna — Virtual Threads (Project Loom)

Introduzidos no Java 21, os Virtual Threads tornam a concorrência muito mais leve e escalável:

Thread.startVirtualThread(() -> executar());

⚙️ Virtual Threads são leves, eficientes e simplificam a concorrência.

Concorrência sem dor de cabeça.

❌ 5. Loops Imperativos em Processamentos Simples

Usar for para filtrar e transformar dados é verboso e propenso a erro:

for (String nome : nomes) {
  if (nome.startsWith("A")) {
      System.out.println(nome.toUpperCase());
  }
}

✅ A solução moderna — Stream API

A Stream API traz clareza e expressividade desde o Java 8, agora mais otimizada nas versões recentes:

nomes.stream()
   .filter(n -> n.startsWith("A"))
   .map(String::toUpperCase)
   .forEach(System.out::println);

🌊 Pensar em streams é pensar em clareza, testabilidade e desempenho.

🧩 Mini Projeto — Tudo Junto e Funcionando

Um exemplo que combina as boas práticas modernas:

public record Usuario(String nome, int idade) {}

public class App {
  public static void main(String[] args) {
      var usuarios = List.of(
          new Usuario("Ana", 25),
          new Usuario("Bruno", 30),
          new Usuario("Amanda", 22)
      );

      usuarios.stream()
              .filter(u -> u.nome().startsWith("A"))
              .map(u -> u.nome().toUpperCase())
              .forEach(System.out::println);

      Thread.startVirtualThread(() -> System.out.println("Processo finalizado!"));
  }
}

🧩 Record, Stream, var e Virtual Thread — tudo em harmonia.

🧭 O Java Está Mais Inteligente (e Você Também Pode Estar)

Os erros de iniciantes sempre existirão.

Mas o Java moderno nos oferece ferramentas poderosas para evitá-los — e quem domina essas ferramentas se destaca no mercado.

💬 Boas práticas não envelhecem, apenas se reinventam. O Java 21+ é mais expressivo, limpo e humano.

Cabe a nós usá-lo com sabedoria — e inspirar outros devs a fazer o mesmo.

📌 Checklist para Código Java Profissional

- ✅ Usa switch expressions para clareza

- ✅ Prefere record para modelar dados imutáveis

- ✅ Captura exceções específicas

- ✅ Usa virtual threads para concorrência leve

- ✅ Processa coleções com Stream API

📚 Referências

💬 E agora?

Compartilhe este artigo com quem ainda programa como em 2005. Vamos juntos elevar o nível do código Java! ☕💻