Herança Intermediaria

O que é herança intermediaria na prática

Herança intermediaria é um padrão de design onde uma classe recebe funcionalidades de múltiplas origens, mas não necessariamente via o modelo clássico de herança simples de linguagem orientada a objeto. Em muitos projetos, vejo gente confundir isso com herança múltipla pura, e aí a coisa quebra rápido. O conceito em si é mais sobre composição estrutural do que sobre syntax. Quando você implementa um sistema que precisa de comportamento compartilhado entre subclasses sem criar uma árvore de herança profunda, a herança intermediaria surge naturalmente. Eu já tive um projeto em Python onde tínhamos entidades de usuário, cliente, vendedor e admin, todos precisando de logs de auditoria, timestamps e soft-delete. Tentar colocar tudo numa classe base única gerava um monstro com cinquenta métodos. A solução foi criar uma classe intermediária que agrupava apenas esse comportamento transversal e depois herdar dela nas subclasses específicas.

Como implementar herança intermediaria corretamente

O primeiro passo é mapear quais responsabilidades são comuns e quais são específicas. Anote tudo em papel ou num documento. Não pule essa parte, porque é aqui que a maioria erra e cria classes base cheias de código que só uma subclasse usa. Vamos a um exemplo prático em Python. Imagine um sistema de notificações onde SMS, email e push precisam compartilhar lógica de template, mas cada um tem seu próprio transporte: class NotificacaoBase:\n def __init__(self, template_engine):\n self.engine = template_engine\n\n def render(self, contexto):\n return self.engine.render(\"notificacao.html\", contexto)\n\nclass NotificacaoIntermediaria(NotificacaoBase):\n def enviar(self, destino, mensagem):\n texto = self.render({\"msg\": mensagem})\n return self._transportar(destino, texto)\n\n def _transportar(self, destino, texto):\n raise NotImplementedError

A partir daí, cada concretização herda da intermediária: class SMS(NotificacaoIntermediaria):\n def _transportar(self, destino, texto):\n return gateway_sms.enviar(destino, texto) class Email(NotificacaoIntermediaria):\n def _transportar(self, destino, texto):\n return gateway_email.enviar(destino, texto)

Esse padrão corta a duplicação de código de renderização e mantém cada classe concreta focada no que realmente importa. Em projetos menores, dá pra economizar uns trinta por cento de linhas de código desnecessárias. Em projetos maiores, isso evita que a manutenção vire um pesadelo.

Problemas que eu encontrei no mundo real

Num projeto recente, precisei lidar com herança intermediaria num cenário onde a classe intermediária também precisava sobrescrever inicialização. O problema foi que o construtor da classe intermediária chamava um método que estava sendo sobrescrito nas subclasses, e o método ainda não existia no momento da construção. Isso gerava um erro silencioso em algumas linguagens e uma exceção em outras. A workaround foi usar um padrão de dois estágios: inicializar os dados básicos na classe intermediária, mas delegar a configuração específica pra um método separado que é chamado explicitamente após a instanciação. Nada elegante, mas funciona e evita o comportamento imprevisível. Outro ponto que muita gente ignora: herança intermediaria não resolve problemas de acoplamento. Se a classe intermediária muda, todas as subclasses são impactadas. Use esse padrão com moderação e mantenha a interface da classe intermediária o mais estável possível. Alterações nela são mais caras do que alterações numa classe de base comum.

Quando evitar esse padrão

Se você tem apenas duas classes compartilhando comportamento, composition over inheritance é mais simples. Herança intermediaria faz sentido quando o número de subclasses justify a camada extra, geralmente a partir de três classes com comportamento comum significativo. Criar uma camada intermediária só por vaidade arquitetural gera complexidade desnecessária. Também não recomendo usar herança intermediaria em linguagens como Java onde o suporte a múltipla herança é limitado. Nesse caso, interfaces combinadas com classes abstratas podem ser mais adequadas. A herança intermediaria brilha em linguagens como Python, Ruby e PHP que permitem múltipla herança sem tanto atrito. Se você está começando agora, teste o padrão num projeto pequeno antes de aplicar num sistema de produção. A teoria é simples, mas os edge cases aparecem quando menos se espera.