Design Patterns em Java: O Guia Nerd para um Código Mais Inteligente

Se você já se pegou repetindo soluções para problemas semelhantes no seu código Java, bem-vindo ao clube! Felizmente, os mestres do desenvolvimento de software criaram os Design Patterns para nos salvar da repetição infinita e tornar nossos códigos mais organizados e reutilizáveis. Vamos explorar os padrões mais importantes e como aplicá-los no seu projeto.

O que são Design Patterns?

Design Patterns são soluções reutilizáveis para problemas comuns no desenvolvimento de software. Eles seguem princípios da engenharia de software para melhorar a manutenção, reutilização e flexibilidade do código. Os padrões mais conhecidos são catalogados no livro "Design Patterns: Elements of Reusable Object-Oriented Software" de 1994, também chamado de "GoF" (Gang of Four).

Principais Tipos de Design Patterns

Os padrões são classificados em três categorias:

1. Criacionais - Focam na criação de objetos de maneira flexível e eficiente.
2. Estruturais - Definem a composição e relação entre classes e objetos.
3. Comportamentais - Gerenciam interações e responsabilidades entre objetos.

Padrões Criacionais

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

public class Singleton {
  private static Singleton instancia;
  private Singleton() {}
  public static Singleton getInstance() {
      if (instancia == null) {
          instancia = new Singleton();
      }
      return instancia;
  }
}

• Factory Method: Permite criar objetos sem expor a lógica de instanciação diretamente.

public interface Produto {
  void usar();
}
public class ProdutoConcreto implements Produto {
  public void usar() {
      System.out.println("Produto em uso!");
  }
}
public class Fabrica {
  public static Produto criarProduto() {
      return new ProdutoConcreto();
  }
}

Padrões Estruturais

• Adapter: Converte a interface de uma classe em outra que o cliente espera.

public interface TomadaBrasil {
  void conectar();
}
public class TomadaAmericana {
  public void plugIn() {
      System.out.println("Tomada americana conectada");
  }
}
public class Adaptador implements TomadaBrasil {
  private TomadaAmericana tomadaAmericana;
  public Adaptador(TomadaAmericana tomada) {
      this.tomadaAmericana = tomada;
  }
  public void conectar() {
      tomadaAmericana.plugIn();
  }
}

Padrões Comportamentais

• Observer: Define uma dependência "um-para-muitos", notificando automaticamente os inscritos quando algo muda.

import java.util.ArrayList;
import java.util.List;

interface Observer {
  void atualizar(String mensagem);
}
class CanalNotificacao {
  private List<Observer> observers = new ArrayList<>();
  void adicionar(Observer o) { observers.add(o); }
  void notificar(String msg) {
      for (Observer o : observers) {
          o.atualizar(msg);
      }
  }
}
class Usuario implements Observer {
  private String nome;
  Usuario(String nome) { this.nome = nome; }
  public void atualizar(String msg) {
      System.out.println(nome + " recebeu: " + msg);
  }
}

Considerações Finais

Os Design Patterns são como os truques Jedi do mundo da programação: dominá-los pode fazer a diferença entre um código caótico e um sistema bem estruturado. Escolha bem os padrões conforme a necessidade do seu projeto e lembre-se: um padrão mal aplicado pode gerar mais problemas do que soluções. Que a força esteja com seu código! ✨