¿Cuál es el problema del diamante en la herencia múltiple?

Question

Accepted Answer

El **problema del diamante** surge cuando una clase hereda de dos clases que comparten un ancestro común, creando ambigüedad: si ambas clases intermedias anulan un método (o contienen un campo), ¿qué versión obtiene la clase inferior?

## La forma del diamante

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

## En Python (que permite herencia múltiple)

```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 lo resuelve de manera determinista a través del **Method Resolution Order (MRO)** utilizando linearización C3, y `super()` coopera con ese orden.

## Cómo lo manejan los lenguajes

| Lenguaje | Enfoque |
|---|---|
| C++ | Lo permite; la ambigüedad es un error de compilación a menos que lo califiques, o uses `virtual` herencia para compartir una base |
| Java/C# | **Prohíben** la herencia múltiple de clases; permiten múltiples *interfaces* (sin estado, por lo que no hay diamante de datos) |
| Python | Lo permite; resuelve a través de MRO (C3) |
| Scala | **Traits** con un orden de linearización definido |

## Trampa

Incluso con MRO, la herencia múltiple de *estado* se vuelve confusa rápidamente — inicialización base duplicada, cadenas `super()` sorprendentes. Las interfaces/traits (comportamiento, no estado) evitan la mayoría del problema.

## Por qué es importante

Explica una bifurcación importante en el diseño de lenguajes: Java y C# prohibieron específicamente la herencia múltiple de clases para evitar esta ambigüedad, ofreciendo interfaces en su lugar.

Comprender el MRO es práctico en Python: `super()` cooperativo y el orden de mezcla solo tienen sentido una vez que ves cómo se lineariza el diamante.

C++	Lo permite; la ambigüedad es un error de compilación a menos que lo califiques, o uses `virtual` herencia para compartir una base
Java/C#	Prohíben la herencia múltiple de clases; permiten múltiples interfaces (sin estado, por lo que no hay diamante de datos)
Python	Lo permite; resuelve a través de MRO (C3)
Scala	Traits con un orden de linearización definido