Guia Completo de Design Patterns em Java

Se você já se deparou com um código Java complexo, cheio de repetições e difícil de manter, sabe que a solução pode estar em um conceito que vai além da sintaxe: os Design Patterns. Esses padrões são como receitas testadas e aprovadas por décadas de desenvolvimento, criadas para resolver problemas comuns de forma elegante e eficiente. Neste guia, vou te mostrar como aplicá-los no seu dia a dia, usando Java, para transformar seu código em algo organizado, flexível e, claro, mais humano.

Por Que Design Patterns Importam?

Imagine construir uma casa sem um projeto: cada parede seria erguida no improviso, o telhado não se encaixaria e, no final, você teria um lugar ineficiente e caro para manter. No desenvolvimento de software, é a mesma coisa. Design Patterns são projetos arquitetônicos que evitam o caos, oferecendo soluções reutilizáveis para problemas recorrentes.

Em Java, eles se tornam ainda mais poderosos graças à orientação a objetos. Classes, interfaces e herança são ferramentas que, quando usadas com os padrões certos, garantem que seu código não só funcione, mas também evolua sem traumas.

Os 3 Tipos de Design Patterns (e Quando Usar Cada Um)

Design Patterns se dividem em três categorias principais, cada uma resolvendo um tipo específico de problema:

1. Padrões Criacionais (Creational Patterns)

São responsáveis por como os objetos são criados, evitando acoplamento e dando flexibilidade.

Singleton: Garante que uma classe tenha apenas uma instância.

public class DatabaseConnection {  
    private static DatabaseConnection instance;  

    private DatabaseConnection() {}  

    public static DatabaseConnection getInstance() {  
        if (instance == null) {  
            instance = new DatabaseConnection();  
        }  
        return instance;  
    }  
}

Use quando: Precisar de um ponto global de acesso (como conexões de banco de dados).

Factory Method: Delega a criação de objetos para subclasses.

public interface Veiculo {  
    void acelerar();  
}  

public class Carro implements Veiculo {  
    @Override  
    public void acelerar() {  
        System.out.println("Carro acelerando...");  
    }  
}  

public class VeiculoFactory {  
    public Veiculo criarVeiculo(String tipo) {  
        if (tipo.equalsIgnoreCase("carro")) {  
            return new Carro();  
        }  
        throw new IllegalArgumentException("Tipo inválido");  
    }  
}

Use quando: A lógica de criação for complexa ou variável.

2. Padrões Estruturais (Structural Patterns)

Focam em como classes e objetos são compostos para formar estruturas maiores.

Adapter: Converte a interface de uma classe em outra interface esperada pelo cliente.

public class TomadaEuropeia {  
    public void conectar(String voltagem) {  
        System.out.println("Conectado à tomada europeia: " + voltagem);  
    }  
}  

public class AdaptadorEUAParaEuropa extends TomadaEuropeia {  
    public void conectar110V() {  
        super.conectar("220V (adaptado)");  
    }  
}

Use quando: Precisar integrar sistemas com interfaces incompatíveis.

Composite: Trata objetos individuais e composições de objetos uniformemente.

public interface Componente {  
    void renderizar();  
}  

public class Folha implements Componente {  
    @Override  
    public void renderizar() {  
        System.out.println("Renderizando folha...");  
    }  
}  

public class Container implements Componente {  
    private List<Componente> componentes = new ArrayList<>();  

    public void adicionar(Componente componente) {  
        componentes.add(componente);  
    }  

    @Override  
    public void renderizar() {  
        componentes.forEach(Componente::renderizar);  
    }  
}

Use quando: Trabalhar com hierarquias de objetos (como interfaces gráficas).

3. Padrões Comportamentais (Behavioral Patterns)

Definem como objetos interagem e distribuem responsabilidades.

Observer: Notifica múltiplos objetos sobre mudanças em um estado.

public interface Observador {  
    void atualizar(String mensagem);  
}  

public class Usuario implements Observador {  
    @Override  
    public void atualizar(String mensagem) {  
        System.out.println("Notificação recebida: " + mensagem);  
    }  
}  

public class Newsletter {  
    private List<Observador> inscritos = new ArrayList<>();  

    public void inscrever(Observador observador) {  
        inscritos.add(observador);  
    }  

    public void notificar(String mensagem) {  
        inscritos.forEach(obs -> obs.atualizar(mensagem));  
    }  
}

Use quando: Precisar de comunicação flexível entre componentes (como sistemas de eventos).

Strategy: Permite que algoritmos sejam intercambiáveis em tempo de execução.

public interface EstrategiaPagamento {  
    void pagar(double valor);  
}  

public class CartaoCredito implements EstrategiaPagamento {  
    @Override  
    public void pagar(double valor) {  
        System.out.println("Pagando R$" + valor + " via cartão de crédito.");  
    }  
}  

public class Compra {  
    private EstrategiaPagamento estrategia;  

    public void setEstrategia(EstrategiaPagamento estrategia) {  
        this.estrategia = estrategia;  
    }  

    public void finalizar(double valor) {  
        estrategia.pagar(valor);  
    }  
}

Use quando: Houver múltiplas variações de um comportamento (ex.: métodos de pagamento).

Design Patterns Não São Balas de Prata!

Aplicar padrões sem critério é como usar um martelo para parafusos: funciona, mas não é eficiente. Antes de escolher um, pergunte-se:

O problema é recorrente? Se for algo único, talvez uma solução simples seja melhor.
O padrão reduz complexidade ou aumenta? Evite over-engineering.
A equipe conhece o padrão? Padrões obscuros podem virar vilões na manutenção.

Próximos Passos: Como Aprofundar?

Estude o catálogo GoF: O livro “Padrões de Projetos: Soluções Reutilizáveis de Software Orientados a Objetos“ é a bíblia dos padrões.
Refatore projetos antigos: Identifique códigos confusos e veja qual padrão se encaixa.
Experimente frameworks: Spring e Hibernate usam padrões como Proxy e Factory intensamente.

Design Patterns não são teorias abstratas: são ferramentas que tornam seu código previsível, testável e colaborativo. Comece com os padrões mais simples (como Singleton e Observer), entenda seus cenários e, aos poucos, você naturalmente dominará os mais complexos.

Lembre-se: o objetivo não é seguir regras, mas escrever código que você e sua equipe consigam entender daqui a 6 meses. E aí, pronto para transformar seu Java em algo mais elegante?