O que é o problema do diamante em herança múltipla?

Question

Accepted Answer

O **problema do diamante** surge quando uma classe herda de duas classes que compartilham um ancestral comum, criando ambiguidade: se ambas as classes intermediárias sobrescrevem um método (ou possuem um campo), qual versão a classe inferior obtém?

## O diamante

```text
        A  (defines greet())
       / \
      B   C   (each may override greet())
       \ /
        D   ← inherits from B and C: which greet()?
```

## Em Python (que permite herança múltipla)

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                  # multiple inheritance
    pass

print(D().greet())             # "B"  — resolved by MRO, not ambiguous
print(D.__mro__)               # D → B → C → A → object  (C3 linearization)
```

Python resolve de forma determinística através da **Method Resolution Order (MRO)** usando linearização C3, e `super()` coopera com essa ordem.

## Como as linguagens lidam com isso

| Linguagem | Abordagem |
|---|---|
| C++ | Permite; ambiguidade é um erro de compilação a menos que você qualifique, ou use herança `virtual` para compartilhar uma única base |
| Java/C# | **Proíbem** herança múltipla de classes; permitem múltiplas *interfaces* (sem estado, então sem diamante de dados) |
| Python | Permite; resolve via MRO (C3) |
| Scala | **Traits** com uma ordem de linearização definida |

## Armadilha

Mesmo com uma MRO, herança múltipla de *estado* fica confusa rapidamente — inicialização de base duplicada, cadeias `super()` surpreendentes. Interfaces/traits (comportamento, não estado) evitam a maioria dos problemas.

## Por que isso importa

Explica uma grande divisão no design de linguagens: Java e C# proibiram herança múltipla de classes especificamente para evitar essa ambiguidade, oferecendo interfaces em seu lugar.

Compreender a MRO é prático em Python: `super()` cooperativo e ordenação de mixins só fazem sentido uma vez que você vê como o diamante é linearizado.

Linguagem	Abordagem
C++	Permite; ambiguidade é um erro de compilação a menos que você qualifique, ou use herança `virtual` para compartilhar uma única base
Java/C#	Proíbem herança múltipla de classes; permitem múltiplas interfaces (sem estado, então sem diamante de dados)
Python	Permite; resolve via MRO (C3)
Scala	Traits com uma ordem de linearização definida