Come funzionano l'ereditarietà e super()?

Question

Accepted Answer

**L'ereditarietà** consente a una classe di derivarsi da un'altra, riutilizzandone e estendendone il comportamento. **`super()`** chiama i metodi della classe genitore. Python supporta l'**ereditarietà multipla**, risolta da **MRO** (Method Resolution Order).

## Ereditarietà base e super()

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` consente a una sottoclasse di invocare il comportamento genitore — essenziale in `__init__` per eseguire l'impostazione del genitore, e per estendere (non solo sostituire) metodi sovrascritti.

## Estensione vs sovrascrittura completa

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Ereditarietà multipla e MRO

```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):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

Con l'ereditarietà multipla, Python cerca metodi in un ordine linearizzato specifico — l'**MRO**, calcolato dall'algoritmo C3. `D.__mro__` lo mostra; `super()` lo segue. L'MRO assicura che ogni classe sia visitata una volta e i genitori vengano dopo i figli, risolvendo il "problema diamond" in modo prevedibile.

## super() segue l'MRO (non solo il genitore letterale)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## Perché è importante

L'ereditarietà e `super()` sono strumenti OOP fondamentali per riutilizzare ed estendere il comportamento, utilizzati in tutti i framework Python (ad es. subclassing dei modelli Django, gerarchie di eccezioni).

Comprendere `super()` (invocare la logica del genitore, soprattutto in `__init__`) e l'**MRO** è particolarmente importante in Python perché supporta l'**ereditarietà multipla** — l'MRO è ciò che rende la risoluzione dei metodi e le catene `super()` prevedibili in gerarchie complesse e mixin.

Sapere come funziona l'MRO (e che `super()` lo segue) previene confusione nei design a forma di diamond o basati su mixin che sono comuni nelle vere basi di codice Python.