⭐ Python Developer · Chặng 4Bài 3/5Bài học~60 phút

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ế.

Kế thừa, composition, ABC và Protocol trong Python

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
  1. 1. Kế thừa và ghi đè
  2. 2. Lớp trừu tượng: bắt buộc lớp con phải làm gì
  3. 3. Composition: "có một" thay vì "là một"
  4. 4. Protocol: giao diện không cần kế thừa
  5. Tóm tắt
  6. Bài tập

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. QuanLy không viết __init__ nên dùng luôn của NhanVien.
  • 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ết nv là 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).

Quy tắc chọnƯu tiên composition. Chỉ dùng kế thừa khi câu "B là một A" đúng một cách tự nhiên và B dùng được ở mọi chỗ cần A (nhân viên kinh doanh là một nhân viên). "Ô tô có động cơ", "thông báo có kênh gửi": đó là composition.

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 + @abstractmethod bắ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.
  • Protocol mô 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

  1. Viết lớp trừu tượng HinhHoc với dien_tich(); ba lớp con HinhTron, HinhChuNhat, TamGiac.
  2. 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.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.