Kepriye cara inheritance lan super() makaryo?

Question

Accepted Answer

**Inheritance** ngidini sawijining kelas kanggo nurunake saka kelas liyane, nggunakake maneh lan nambahi behavior-ne. **`super()`** nelpon method-method saka kelas induk. Python ndhukung **multiple inheritance**, sing diselesaike dening **MRO** (Method Resolution Order).

## Inheritance lan super() dasar

```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()` ngidini subkelas kanggo nelpon behavior saka induk — penting banget ing `__init__` kanggo njalanake setup induk, lan kanggo nambahi (ora mung ngganti) method-method sing dientas.

## Nambahi versus ngganti sepenuhne

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

## Multiple inheritance lan 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
```

Karo multiple inheritance, Python nggoleki method-method ing urutan linier khusus — **MRO**, sing dihitung dening algoritma C3. `D.__mro__` nampilake-ne; `super()` ngetutake-ne. MRO njamin saben kelas dikunjungi siji kali lan induk-induk teka sawise anak-anak, mbabarake "masalah diamond" kanthi predictable.

## super() ngetutake MRO (ora mung induk literal)

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

## Kenapa iku penting

Inheritance lan `super()` minangka alat OOP inti kanggo nggunakake maneh lan nambahi behavior, digunakake saindhenging framework Python (m.a. subclassing Django model, exception hierarchy).

Pamahaman babagan `super()` (nelpon logika induk, utamane ing `__init__`) lan **MRO** sangat penting ing Python amarga ndhukung **multiple inheritance** — MRO inilah sing ndadekake method resolution lan `super()` chain predictable ing hierarchy kompleks lan mixin.

Ngerti kepriye MRO makaryo (lan manawa `super()` ngetutake) ngenteni kebingungan ing design berbentuk diamond utawa berbasis mixin sing umum ing kode Python nyata.