Kế thừa, composition, ABC và Protocol trong Python
Khi nào kế thừa, khi nào composition: ghi đè, super(), lớp trừu tượng ABC, Protocol và duck typing, kèm ví dụ thiết kế thực tế.
Học xong bài này, bạn sẽ
- Kế thừa và ghi đè phương thức, gọi super()
- Chọn composition khi quan hệ là 'có một'
- Định nghĩa giao diện bằng ABC và Protocol
Nên học trước: Phương thức đặc biệt và property
Nội dung bài viết
Khi nhiều lớp có phần giống nhau, bạn có hai cách dùng lại code: kế thừa (lớp con "là một" lớp cha) và composition (lớp "có một" đối tượng khác bên trong). Chọn sai cách là nguồn gốc của rất nhiều code rối. Bài này dạy cả hai, cùng cách định nghĩa "giao diện" bằng lớp trừu tượng và Protocol.
1. Kế thừa và ghi đè
class NhanVien:
def __init__(self, ten: str, luong_co_ban: int):
self.ten = ten
self.luong_co_ban = luong_co_ban
def tinh_luong(self) -> int:
return self.luong_co_ban
def __repr__(self):
return f"{type(self).__name__}({self.ten!r})"
class NhanVienKinhDoanh(NhanVien): # kế thừa NhanVien
def __init__(self, ten: str, luong_co_ban: int, doanh_so: int):
super().__init__(ten, luong_co_ban) # gọi __init__ của lớp cha
self.doanh_so = doanh_so
def tinh_luong(self) -> int: # ghi đè (override)
return super().tinh_luong() + int(self.doanh_so * 0.05)
class QuanLy(NhanVien):
PHU_CAP = 5_000_000
def tinh_luong(self) -> int:
return self.luong_co_ban + self.PHU_CAP
cong_ty = [NhanVien("An", 12_000_000), NhanVienKinhDoanh("Bình", 10_000_000, 200_000_000),
QuanLy("Chi", 25_000_000)]
for nv in cong_ty:
print(f"{nv!r:<28}{nv.tinh_luong():>12,}")
print(isinstance(cong_ty[2], NhanVien), issubclass(QuanLy, NhanVien))
NhanVien('An') 12,000,000
NhanVienKinhDoanh('Bình') 20,000,000
QuanLy('Chi') 30,000,000
True True
class Con(Cha):thừa hưởng mọi thuộc tính, phương thức của lớp cha.QuanLykhông viết__init__nên dùng luôn củaNhanVien.- Ghi đè: lớp con định nghĩa lại phương thức cùng tên.
super().ten_phuong_thuc()gọi bản của lớp cha để mở rộng thay vì viết lại từ đầu. - Đa hình: vòng lặp gọi
nv.tinh_luong()mà không cần biếtnvlà loại nào; mỗi đối tượng tự biết cách tính của mình. Thêm loại nhân viên mới không phải sửa vòng lặp.
2. Lớp trừu tượng: bắt buộc lớp con phải làm gì
from abc import ABC, abstractmethod
import math
class HinhHoc(ABC):
@abstractmethod
def dien_tich(self) -> float: ...
def mo_ta(self) -> str: # phương thức dùng chung, dựa trên phương thức trừu tượng
return f"{type(self).__name__}: diện tích {self.dien_tich():.2f}"
class HinhTron(HinhHoc):
def __init__(self, r: float):
self.r = r
def dien_tich(self) -> float:
return math.pi * self.r ** 2
class HinhVuong(HinhHoc):
def __init__(self, canh: float):
self.canh = canh
# quên viết dien_tich
print(HinhTron(1).mo_ta())
try:
HinhVuong(2)
except TypeError as loi:
print("Lỗi:", loi)
HinhTron: diện tích 3.14
Lỗi: Can't instantiate abstract class HinhVuong without an implementation for abstract method 'dien_tich'
Lớp kế thừa ABC có phương thức @abstractmethod thì không tạo đối tượng được, và lớp con nào quên viết phương thức đó cũng bị chặn ngay lúc tạo đối tượng, thay vì đợi đến lúc gọi mới lỗi.
3. Composition: "có một" thay vì "là một"
Giả sử bạn cần gửi thông báo qua email hoặc SMS, và mỗi thông báo có thể ghi log hoặc không. Dùng kế thừa sẽ sinh ra ThongBaoEmail, ThongBaoSMS, ThongBaoEmailCoLog, ThongBaoSMSCoLog... số lớp tăng theo cấp số nhân. Composition giải quyết gọn: thông báo có một kênh gửi, kênh được truyền vào từ ngoài.
class KenhEmail:
def gui(self, den: str, noi_dung: str) -> str:
return f"[email → {den}] {noi_dung}"
class KenhSMS:
def gui(self, den: str, noi_dung: str) -> str:
return f"[sms → {den}] {noi_dung[:30]}" # SMS giới hạn độ dài
class KenhGia:
"""Kênh giả dùng khi kiểm thử: không gửi thật, chỉ ghi lại."""
def __init__(self):
self.da_gui: list[tuple[str, str]] = []
def gui(self, den: str, noi_dung: str) -> str:
self.da_gui.append((den, noi_dung))
return "ok"
class DichVuThongBao:
def __init__(self, kenh): # nhận kênh từ bên ngoài
self.kenh = kenh
def bao_don_hang(self, den: str, ma_don: str) -> str:
return self.kenh.gui(den, f"Đơn {ma_don} đã được giao cho đơn vị vận chuyển")
print(DichVuThongBao(KenhEmail()).bao_don_hang("an@x.vn", "DH001"))
print(DichVuThongBao(KenhSMS()).bao_don_hang("0912345678", "DH002"))
gia = KenhGia()
DichVuThongBao(gia).bao_don_hang("test", "DH003")
print(gia.da_gui)
[email → an@x.vn] Đơn DH001 đã được giao cho đơn vị vận chuyển
[sms → 0912345678] Đơn DH002 đã được giao cho đơn
[('test', 'Đơn DH003 đã được giao cho đơn vị vận chuyển')]
Kỹ thuật "truyền phụ thuộc từ ngoài vào" gọi là dependency injection. Lợi ích thấy ngay ở KenhGia: kiểm thử DichVuThongBao mà không gửi email thật. Bạn sẽ gặp lại ý tưởng này trong pytest (chặng 6) và FastAPI (chặng 9, với Depends).
4. Protocol: giao diện không cần kế thừa
Ở mục 3, ba lớp kênh không kế thừa gì cả; chúng chỉ cùng có phương thức gui. Đó là duck typing: "đi như vịt, kêu như vịt thì là vịt". typing.Protocol giúp ghi rõ điều này cho công cụ kiểm tra kiểu:
from typing import Protocol
class KenhGui(Protocol):
def gui(self, den: str, noi_dung: str) -> str: ...
class KenhZalo: # không kế thừa KenhGui
def gui(self, den: str, noi_dung: str) -> str:
return f"[zalo → {den}] {noi_dung}"
def thong_bao(kenh: KenhGui, den: str) -> str:
return kenh.gui(den, "Xin chào")
print(thong_bao(KenhZalo(), "Lan"))
[zalo → Lan] Xin chào
Khi chạy, Python không kiểm tra gì thêm. Nhưng mypy hoặc Pylance sẽ báo lỗi nếu bạn truyền một đối tượng thiếu phương thức gui hoặc sai kiểu tham số (chặng 5 dạy mypy). So với ABC: ABC buộc lớp con phải kế thừa; Protocol chỉ cần "có đúng hình dạng", hợp với cả lớp của thư viện bên ngoài mà bạn không sửa được.
Tóm tắt
- Kế thừa
class Con(Cha), ghi đè phương thức,super()để mở rộng bản của cha. ABC+@abstractmethodbắt buộc lớp con cài đặt.- Composition: đối tượng chứa đối tượng khác, nhận từ ngoài vào (dependency injection); ưu tiên hơn kế thừa.
Protocolmô tả giao diện theo hình dạng, không cần kế thừa.
Bài tập
Bài 1. Ba hình học
Dựa trên HinhHoc ở mục 2, viết HinhTron, HinhChuNhat, TamGiac (ba cạnh, dùng công thức Heron), sắp xếp danh sách hình theo diện tích.
Xem đáp án
import math
from abc import ABC, abstractmethod
class HinhHoc(ABC):
@abstractmethod
def dien_tich(self) -> float: ...
def __repr__(self):
return f"{type(self).__name__}({self.dien_tich():.2f})"
class HinhTron(HinhHoc):
def __init__(self, r):
self.r = r
def dien_tich(self):
return math.pi * self.r ** 2
class HinhChuNhat(HinhHoc):
def __init__(self, dai, rong):
self.dai, self.rong = dai, rong
def dien_tich(self):
return self.dai * self.rong
class TamGiac(HinhHoc):
def __init__(self, a, b, c):
if a + b <= c or a + c <= b or b + c <= a:
raise ValueError("Ba cạnh không tạo thành tam giác")
self.a, self.b, self.c = a, b, c
def dien_tich(self):
p = (self.a + self.b + self.c) / 2
return math.sqrt(p * (p - self.a) * (p - self.b) * (p - self.c))
hinh = [HinhTron(1.5), HinhChuNhat(2, 3), TamGiac(3, 4, 5)]
print(sorted(hinh, key=lambda h: h.dien_tich()))
[HinhChuNhat(6.00), TamGiac(6.00), HinhTron(7.07)]
Hình chữ nhật 2 × 3 và tam giác 3-4-5 cùng diện tích 6. sorted là sắp xếp ổn định: các phần tử có key bằng nhau giữ nguyên thứ tự như trong list gốc, nên hình chữ nhật (đứng trước trong hinh) vẫn đứng trước tam giác. Vòng lặp sắp xếp gọi dien_tich() trên mọi hình mà không cần biết hình nào là loại gì: đó là đa hình.
Bài 2. Thông báo nhiều kênh
Viết lớp KenhNhieu nhận một list kênh và gửi qua tất cả; dùng nó với DichVuThongBao mà không sửa lớp đó.
Xem đáp án
class KenhEmail:
def gui(self, den, noi_dung):
return f"email:{den}"
class KenhSMS:
def gui(self, den, noi_dung):
return f"sms:{den}"
class KenhNhieu:
def __init__(self, cac_kenh):
self.cac_kenh = list(cac_kenh)
def gui(self, den, noi_dung):
return " | ".join(k.gui(den, noi_dung) for k in self.cac_kenh)
class DichVuThongBao:
def __init__(self, kenh):
self.kenh = kenh
def bao_don_hang(self, den, ma_don):
return self.kenh.gui(den, f"Đơn {ma_don} đã giao")
print(DichVuThongBao(KenhNhieu([KenhEmail(), KenhSMS()])).bao_don_hang("An", "DH9"))
email:An | sms:An
KenhNhieu có cùng "hình dạng" với một kênh (có gui) nên DichVuThongBao dùng được ngay. Đây là mẫu thiết kế Composite: một nhóm đối tượng được dùng như một đối tượng.
Nguồn tham khảo: Python Tutorial: Inheritance; abc: Abstract Base Classes; Typing spec: Protocols.
Bài tập thực hành
- Viết lớp trừu tượng HinhHoc với dien_tich(); ba lớp con HinhTron, HinhChuNhat, TamGiac.
- Viết hệ thống gửi thông báo dùng composition: lớp ThongBao nhận một đối tượng kênh gửi (Email, SMS).
Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.


