Bagaimana cara kerja pewarisan dan super()?

Question

Accepted Answer

**Pewarisan** memungkinkan kelas untuk diturunkan dari kelas lain, menggunakan kembali dan memperluas perilakunya. **`super()`** memanggil metode kelas induk. Python mendukung **pewarisan berganda**, yang diselesaikan oleh **MRO** (Method Resolution Order).

## Pewarisan dasar dan 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()` memungkinkan subkelas untuk memanggil perilaku induk — penting dalam `__init__` untuk menjalankan setup induk, dan untuk memperluas (bukan hanya mengganti) metode yang ditimpa.

## Memperluas vs sepenuhnya menimpa

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

## Pewarisan berganda dan 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
```

Dengan pewarisan berganda, Python mencari metode dalam urutan linear tertentu — **MRO**, dihitung oleh algoritma C3. `D.__mro__` menampilkannya; `super()` mengikutinya. MRO memastikan setiap kelas dikunjungi sekali dan induk datang setelah anak, menyelesaikan "masalah diamond" secara dapat diprediksi.

## super() mengikuti MRO (bukan hanya induk harfiah)

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

## Mengapa ini penting

Perwarisan dan `super()` adalah alat OOP inti untuk menggunakan kembali dan memperluas perilaku, digunakan di seluruh kerangka kerja Python (misalnya subclassing model Django, hierarki pengecualian).

Memahami `super()` (memanggil logika induk, khususnya dalam `__init__`) dan **MRO** sangat penting dalam Python karena mendukung **pewarisan berganda** — MRO adalah apa yang membuat resolusi metode dan rantai `super()` dapat diprediksi dalam hierarki kompleks dan mixin.

Mengetahui cara kerja MRO (dan bahwa `super()` mengikutinya) mencegah kebingungan dalam desain berbentuk diamond atau berbasis mixin yang umum dalam basis kode Python nyata.