Kako rade naslijeđivanje i super()?

Question

Accepted Answer

**Naslijeđivanje** omogućava klasi da se izvedu iz druge, ponovno koristeći i proširujući njezino ponašanje. **`super()`** poziva metode roditeljske klase. Python podržava **višestruko naslijeđivanje**, razriješeno sa **MRO** (redoslijed rezolucije metode).

## Osnovno naslijeđivanje i 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()` omogućava podklasi da pozove ponašanje roditelja — bitno u `__init__` da se pokrene postava roditelja, te da se prošire (ne samo zamijene) nadjačane metode.

## Proširivanje naspram potpunog nadjačavanja

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

## Višestruko naslijeđivanje 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
```

Sa višestrukim naslijeđivanjem, Python pretražuje metode u specifičnom lineariziranom redoslijedu — **MRO**, izračunatom C3 algoritmom. `D.__mro__` ga prikazuje; `super()` ga slijedi. MRO osigurava da se svaka klasa posjeti samo jednom te da roditelji dolaze nakon djece, predvidivo rješavajući "problem dijamantu".

## super() slijedi MRO (ne samo doslovno roditeljsku klasu)

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

## Zašto je to važno

Naslijeđivanje i `super()` su temeljni OOP alati za ponovno korištenje i proširivanje ponašanja, korišteni u cijelim Python okvirima (npr. subklasiranje Django modela, hijerarhije iznimaka).

Razumijevanje `super()` (pozivanje logike roditelja, posebno u `__init__`) i **MRO** je posebno važno u Pythonu jer podržava **višestruko naslijeđivanje** — MRO je ono što čini rezoluciju metode i `super()` lancima predvidivim u složenim hijerarhijama i mixinima.

Znanje kako MRO funkcionira (i da `super()` slijedi ga) sprječava zbunjenost u dijamantski oblikovanim ili mixin-baziranim dizajnima koji su česti u stvarnim Python bazama koda.