1) Abordagem prática para aprender Design Patterns

Meu objetivo aqui é transformar teoria em prática sólida. Em projetos reais, padrões aparecem como soluções de baixo acoplamento e maior extensibilidade. Adoto uma estratégia em quatro passos:

• Definir o problema em termos de operações estáticas versus comportamentais.
• Isolar a variação de comportamento usando padrões apropriados (Strategy, Observer, etc.).
• Construir pequenos protótipos que demonstrem a troca de comportamento sem alterar o cliente.
• Refatorar com foco em legibilidade, testabilidade e evolução futura.

Neste post, proponho projetos práticos que cobrem padrões comportamentais e estruturais, com exemplos que você pode adaptar a linguagens como JavaScript, TypeScript ou qualquer linguagem orientada a objetos.

2) Padrões-chave com exemplos práticos

Os seguintes padrões costumam aparecer com frequência em sistemas reais. A cada item, trago uma explicação objetiva do uso, quando preferi-lo e uma amostra de código simples para ilustrar a ideia.

Strategy

O Strategy permite trocar o algoritmo de um comportamento em tempo de execução. Útil para escolher, por exemplo, métricas de desconto, frete ou ordenação, sem modificar o código do cliente.

// Strategy pattern em JavaScript (descontos)
class DiscountStrategy {
  apply(price) { throw new Error('abstract') }
}
class NoDiscount extends DiscountStrategy {
  apply(price) { return price; }
}
class PercentageDiscount extends DiscountStrategy {
  constructor(percent) { super(); this.percent = percent; }
  apply(price) { return price * (1 - this.percent); }
}
class FixedDiscount extends DiscountStrategy {
  constructor(amount) { super(); this.amount = amount; }
  apply(price) { return Math.max(0, price - this.amount); }
}
class Checkout {
  constructor(strategy) { this.strategy = strategy; }
  setStrategy(strategy) { this.strategy = strategy; }
  total(price) { return this.strategy.apply(price); }
}

// Uso
const checkout = new Checkout(new NoDiscount());
console.log(checkout.total(100)); // 100
checkout.setStrategy(new PercentageDiscount(0.15));
console.log(checkout.total(100)); // 85
      

Factory

Factory centraliza a criação de objetos, abstraindo as decisões de instanciá-los. Ideal para manter coesão quando há famílias de objetos relacionados.

Observer

Observer facilita notificar partes do sistema sobre eventos. Excelente para UI reativa, logs ou sincronização entre componentes sem acoplamento duro.

Decorator

Decorator adiciona responsabilidades a objetos dinamicamente, sem modificar a hierarquia de classes. Útil para composição de comportamentos em tempo de execução.

Observação: estes quatro padrões cobrem uma grande parte de cenários do dia a dia. Em muitos casos, você combina dois ou mais para alcançar a solução desejada de forma elegante.

3) Projetos práticos para internalizar os padrões

1. Calculadora de descontos com Strategy:
   implemente uma função de checkout que possa trocar entre descontos por percentagem, valor fixo ou nenhum desconto, sem modificar a lógica de venda.
2. Sistema de notificações com Observer:
   crie um serviço que notifica diferentes ouvintes (email, UI, logs) quando uma venda é concluída.
3. Gerador de objetos com Factory:
   construa uma fábrica que produz diferentes tipos de objeto (produto simples, serviço, transporte) com base no input.
4. Extensão de comportamento com Decorator:
   permita adicionar funcionalidades a um objeto de forma dinâmica (ex.: caching, validação extra) sem criar subclasses.

Para cada projeto, defina: objetivos de saída, entradas, cenários de teste e critérios de aceitação. Comece com uma implementação mínima, depois evolua para padrões mais avançados conforme a necessidade.

4) Boas práticas, testes e evolução

• Escreva pequenos commits com mensagens descritivas: genotype do padrão, não apenas a funcionalidade.
• Valide cada patamar com testes unitários que exercitem cenários de variação de comportamento.
• Priorize a legibilidade do código sobre a complexidade de implementações; padrões devem clarear o design.
• Refatore para extrair estratégias, observadores ou decorators à medida que novos requisitos surgem.

Ao final, revise se cada padrão resolve um problema de acoplamento, coesão ou extensibilidade, mantendo o código cliente simples e estável para evoluções futuras.

Pronto para avançar?

Explore mais conteúdos com foco técnico e prático. Abaixo, sugestões de leitura para aprofundar seu domínio em design patterns.

• Princípios SOLID na prática
• Padrões estruturais em foco
• Padrões comportamentais: manual rápido

Continue lendo mais posts práticos