Open-Closed Principle: Restaurante Sistema Implacável

Você adiciona um novo prato no cardápio e o sistema inteiro quebra. Modifica desconto de pizza e hambúrguer para de funcionar. Open-Closed Principle resolve essa matemática venenosa da extensibilidade.

Problema Real: Sistema Frágil

Restaurante precisa calcular preços diferentes por tipo de prato. Pizza tem taxa de forno, hambúrguer tem desconto horário, salada tem adicional orgânico.

function calcularPreco(prato: any): number {
  let preco = prato.precoBase;
  
  if (prato.tipo === 'pizza') {
    preco += 5; // Taxa do forno
  } else if (prato.tipo === 'hamburguer') {
    if (isHorarioPromocional()) {
      preco *= 0.8; // 20% desconto
    }
  } else if (prato.tipo === 'salada') {
    preco += 3; // Adicional orgânico
  }
  
  return preco;
}

Open-Closed Principle: Definição Precisa

Solução: Polimorfismo Estratégico

Orientação a objetos com herança resolve a matemática da extensibilidade. Cada tipo de prato vira uma classe independente.

abstract class Prato {
  constructor(
    protected nome: string,
    protected precoBase: number
  ) {}
  
  abstract calcularPreco(): number;
  abstract getDescricao(): string;
}

class Pizza extends Prato {
  calcularPreco(): number {
    return this.precoBase + 5; // Taxa do forno
  }
  
  getDescricao(): string {
    return `${this.nome} - Pizza artesanal`;
  }
}

class Hamburguer extends Prato {
  calcularPreco(): number {
    let preco = this.precoBase;
    
    if (this.isHorarioPromocional()) {
      preco *= 0.8; // 20% desconto
    }
    
    return preco;
  }
  
  private isHorarioPromocional(): boolean {
    const hora = new Date().getHours();
    return hora >= 14 && hora <= 17; // 14h às 17h
  }
  
  getDescricao(): string {
    return `${this.nome} - Hambúrguer gourmet`;
  }
}

Extensão Sem Modificação

Restaurante decide adicionar sobremesas no cardápio. Com OCP, você não toca em pizza nem hambúrguer.

class Sobremesa extends Prato {
  constructor(
    nome: string,
    precoBase: number,
    private temCobertura: boolean = false
  ) {
    super(nome, precoBase);
  }
  
  calcularPreco(): number {
    let preco = this.precoBase;
    
    if (this.temCobertura) {
      preco += 4; // Adicional cobertura
    }
    
    return preco;
  }
  
  getDescricao(): string {
    const cobertura = this.temCobertura ? 'com cobertura' : 'simples';
    return `${this.nome} - Sobremesa ${cobertura}`;
  }
}

Uso Prático do Sistema

// Sistema do restaurante
const cardapio: Prato[] = [
  new Pizza('Margherita', 25),
  new Hamburguer('Big Burger', 18),
  new Sobremesa('Torta de Chocolate', 12, true),
  new Sobremesa('Pudim', 8, false)
];

// Calculadora de pedido
function calcularPedido(pratos: Prato[]): void {
  let total = 0;
  
  pratos.forEach(prato => {
    const preco = prato.calcularPreco();
    console.log(`${prato.getDescricao()}: R$ ${preco}`);
    total += preco;
  });
  
  console.log(`Total: R$ ${total}`);
}

calcularPedido(cardapio);

Margherita - Pizza artesanal: R$ 30
Big Burger - Hambúrguer gourmet: R$ 14.4
Torta de Chocolate - Sobremesa com cobertura: R$ 16
Pudim - Sobremesa simples: R$ 8
Total: R$ 68.4

Vantagens Técnicas Severas

Casos de Uso Avançados

OCP não se limita a cálculo de preços. Aplicação se estende para qualquer comportamento extensível.

abstract class ProcessadorPagamento {
  abstract processar(valor: number): Promise<boolean>;
}

class PagamentoPix extends ProcessadorPagamento {
  async processar(valor: number): Promise<boolean> {
    // Lógica específica do PIX
    return true;
  }
}

class PagamentoCartao extends ProcessadorPagamento {
  async processar(valor: number): Promise<boolean> {
    // Lógica específica do cartão
    return true;
  }
}

Implementação Step-by-Step

Próximos Passos

OCP é apenas um dos 5 princípios SOLID. Domine todos para escrever código que escala sem quebrar.