Kế thừa và super() hoạt động như thế nào?

Question

Accepted Answer

**Kế thừa** cho phép một class dẫn xuất từ một class khác, tái sử dụng và mở rộng hành vi của nó. **`super()`** gọi các method của class cha. Python hỗ trợ **đa kế thừa**, được giải quyết bởi **MRO** (Method Resolution Order — thứ tự phân giải method).

## Kế thừa cơ bản và super()

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog kế thừa từ Animal
    def __init__(self, name, breed):
        super().__init__(name)       # gọi __init__ của cha (tái sử dụng logic của nó)
        self.breed = breed
    def speak(self):                 # GHI ĐÈ method của cha
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (được đặt bởi Animal qua super())
d.speak()   # "Woof" (ghi đè của Dog)
```

`super()` cho phép một class con gọi hành vi của cha — thiết yếu trong `__init__` để chạy thiết lập của cha, và để mở rộng (không chỉ thay thế) các method được ghi đè.

## Mở rộng vs ghi đè hoàn toàn

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # gọi cha, rồi THÊM vào nó
        return f"{base} ... Meow"
```

## Đa kế thừa và 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):                       # kế thừa từ CẢ B và C
    pass

D().greet()       # "B" — tìm thấy qua MRO
D.__mro__         # (D, B, C, A, object) — thứ tự tìm kiếm
```

Với đa kế thừa, Python tìm kiếm method theo một thứ tự tuyến tính hóa cụ thể — **MRO**, được tính bởi thuật toán C3. `D.__mro__` hiển thị nó; `super()` đi theo nó. MRO đảm bảo mỗi class được ghé thăm một lần và các class cha đứng sau các class con, giải quyết "bài toán kim cương" (diamond problem) một cách dễ đoán.

## super() đi theo MRO (không chỉ class cha trực tiếp)

```python
# trong đa kế thừa hợp tác (cooperative), super() đi tới class TIẾP THEO trong MRO,
# không nhất thiết là "cha" — cho phép các mixin nối chuỗi đúng cách
```

## Tại sao điều này quan trọng

Kế thừa và `super()` là các công cụ OOP cốt lõi để tái sử dụng và mở rộng hành vi, được dùng xuyên suốt các framework Python (ví dụ kế thừa các model Django, các hệ thống phân cấp ngoại lệ).

Hiểu `super()` (gọi logic của cha, đặc biệt trong `__init__`) và **MRO** đặc biệt quan trọng trong Python vì nó hỗ trợ **đa kế thừa** — MRO là thứ làm cho việc phân giải method và các chuỗi `super()` trở nên dễ đoán trong các hệ thống phân cấp phức tạp và mixin.

Biết MRO hoạt động như thế nào (và rằng `super()` đi theo nó) ngăn được sự bối rối trong các thiết kế hình kim cương hoặc dựa trên mixin vốn phổ biến trong các codebase Python thực tế.