Cum funcționează moștenirea și super()?

Question

Accepted Answer

**Moștenirea** permite unei clase să derive din alta, reutilizând și extinzând comportamentul acesteia. **`super()`** apelează metodele clasei părintelui. Python suportă **moștenirea multiplă**, rezolvată prin **MRO** (Method Resolution Order).

## Moștenire și super() de bază

```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()` permite unei subclase să invoce comportamentul clasei părintelui — esențial în `__init__` pentru a rula configurarea părintelui și a extinde (nu doar înlocui) metodele suprascrise.

## Extindere vs înlocuire completă

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

## Moștenire multiplă și 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
```

Cu moștenire multiplă, Python caută metode într-o ordine linearizată specifică — **MRO**, calculată prin algoritmul C3. `D.__mro__` o afișează; `super()` o urmează. MRO asigură că fiecare clasă este vizitată o dată și părinții vin după copii, rezolvând "diamond problem" în mod previzibil.

## super() urmează MRO (nu doar părintele literal)

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

## De ce contează

Moștenirea și `super()` sunt instrumente OOP de bază pentru reutilizarea și extinderea comportamentului, utilizate în întreaga ecosistemă frameworkurilor Python (de exemplu, subclasarea modelelor Django, ierarhii de excepții).

Înțelegerea `super()` (apelarea logicii părintelui, în special în `__init__`) și a **MRO** este deosebit de importantă în Python deoarece suportă **moștenire multiplă** — MRO este ceea ce face rezoluția metodelor și lanțurile `super()` previzibile în ierarhii complexe și mixine.

Cunoașterea modului în care funcționează MRO (și că `super()` o urmează) previne confuzia în design-uri în formă de diamant sau bazate pe mixine, care sunt comune în bazele de cod Python reale.