Hoe werken overerving en super()?

Question

Accepted Answer

**Overerving** stelt een klasse in staat af te stammen van een andere klasse, waarbij het gedrag wordt hergebruikt en uitgebreid. **`super()`** roept de methoden van de bovenliggende klasse aan. Python ondersteunt **meervoudige overerving**, opgelost door **MRO** (Method Resolution Order).

## Basis-overerving en 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()` stelt een subklasse in staat het gedrag van de bovenliggende klasse aan te roepen — essentieel in `__init__` om de instelling van de bovenliggende klasse uit te voeren, en om overschreven methoden uit te breiden (niet alleen te vervangen).

## Uitbreiding versus volledig overschrijven

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

## Meervoudige overerving en 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
```

Bij meervoudige overerving zoekt Python naar methoden in een specifieke lineaire volgorde — **MRO**, berekend door het C3-algoritme. `D.__mro__` toont het; `super()` volgt het. De MRO zorgt ervoor dat elke klasse eenmaal wordt bezocht en ouders na kinderen komen, wat het "diamantprobleem" voorspelbaar oplost.

## super() volgt de MRO (niet alleen de letterlijke ouder)

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

## Waarom het belangrijk is

Overerving en `super()` zijn kerntools van OOP voor het hergebruiken en uitbreiden van gedrag, gebruikt in hele Python-frameworks (bijv. subclassing van Django-modellen, uitzonderingshiërarchieën).

Begrip van `super()` (het aanroepen van bovenliggende logica, vooral in `__init__`) en **MRO** is vooral belangrijk in Python omdat het **meervoudige overerving** ondersteunt — de MRO is wat methoderesolutie en `super()`-ketens in complexe hiërarchieën en mixins voorspelbaar maakt.

Weten hoe de MRO werkt (en dat `super()` deze volgt) voorkomt verwarring in diamantvormig of mixin-gebaseerd ontwerp dat gebruikelijk is in echte Python-codebases.