Hvordan fungerer nedarving og `super()`?

Question

Accepted Answer

**Nedarving** lader en klasse arve fra en anden og genbruge og udvide dens adfærd. **`super()`** kalder forældreklassens metoder. Python understøtter **multipel nedarving**, løst af **MRO** (Method Resolution Order).

## Grundlæggende nedarving og 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()` lader en subklasse påkalde forældrenes adfærd — vigtig i `__init__` for at køre forældrenes opsætning og for at udvide (ikke bare erstatte) overstyrede metoder.

## Udvidelse vs. fuldstændig overstyring

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

## Multipel nedarving og 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
```

Med multipel nedarving søger Python efter metoder i en specifik lineariseret rækkefølge — **MRO**, beregnet af C3-algoritmen. `D.__mro__` viser det; `super()` følger det. MRO sikrer, at hver klasse besøges én gang og forældre kommer efter børn, hvilket løser "diamantproblemet" forudsigeligt.

## super() følger MRO (ikke bare den bogstavelige forældreklasse)

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

## Hvorfor det betyder noget

Nedarving og `super()` er kerneobjektorienterede værktøjer til at genbruge og udvide adfærd, brugt gennem Python-frameworks (f.eks. subklasser af Django-modeller, undtagelseshierarkier).

Forståelse af `super()` (kald af forældrenes logik, især i `__init__`) og **MRO** er særligt vigtig i Python, fordi den understøtter **multipel nedarving** — MRO er det, der gør metodeopløsning og `super()`-kæder forudsigelige i komplekse hierarkier og mixins.

Kendskab til, hvordan MRO fungerer (og at `super()` følger det), forhindrer forvirring i diamantformede eller mixin-baserede designs, som er almindelige i virkelige Python-kodebaser.