Abstract Class và Interface trong Python: Khi nào nên dùng cái nào?

Bài viết này sẽ giúp bạn phân biệt rõ ràng và áp dụng chúng một cách chuyên nghiệp nhất trong Python.

1. Abstract Class (Lớp trừu tượng) là gì?

Khái niệm: Là một lớp cơ sở định hình khung chung nhưng không cho phép khởi tạo trực tiếp (không thể tạo instance bằng MyClass()). Nó có thể chứa cả phương thức trừu tượng (bắt buộc lớp con viết lại) và phương thức thông thường (có sẵn logic để lớp con kế thừa).
Mối quan hệ: Đại diện cho mối quan hệ "IS-A" chặt chẽ (Ví dụ: MySQLConnection là một DatabaseConnection).

from abc import ABC, abstractmethod

class DatabaseConnection(ABC):
    
    # Phương thức thông thường (Lớp con dùng luôn không cần viết lại)
    def connect_log(self):
        print("Initializing connection sequence...")

    # Phương thức trừu tượng (Bắt buộc lớp con phải tự định nghĩa)
    @abstractmethod
    def execute_query(self, query: str) -> list:
        pass

class MySQLConnection(DatabaseConnection):
    def execute_query(self, query: str) -> list:
        print(f"Executing query on MySQL: {query}")
        return ["result_1", "result_2"]

2. Interface (Giao diện / Khả năng) trong Python

Khái niệm: Trong Python, Interface thường được mô phỏng thông qua Abstract Class hoàn toàn (chỉ chứa các phương thức trừu tượng và không có bất kỳ logic code nào bên trong).
Mối quan hệ: Đại diện cho mối quan hệ "CAN-DO" (Có khả năng làm gì đó). Một lớp có thể implement nhiều Interface cùng lúc để bổ sung các hành vi độc lập.

class Exportable(ABC):
    @abstractmethod
    def to_json(self) -> str:
        pass

class Printable(ABC):
    @abstractmethod
    def print_document(self) -> None:
        pass

# Đa kế thừa các Interface (Mixin pattern)
class Report(Exportable, Printable):
    def to_json(self) -> str:
        return '{"title": "Monthly Report"}'

    def print_document(self) -> None:
        print("Printing report to printer...")

3. Bảng so sánh nhanh: Abstract Class vs. Interface

Tiêu chíAbstract Class (Lớp trừu tượng)Interface (Giao diện)Mục đích thiết kếChia sẻ mã nguồn chung và định nghĩa khung cấu trúc cốt lõi (IS-A).Định nghĩa tập hợp các hành vi độc lập mà một lớp phải có (CAN-DO).Thành phần chứaCó thể chứa cả phương thức có nội dung và phương thức trừu tượng.Chỉ chứa các phương thức trừu tượng (không có code bên trong).Kế thừaMột lớp con chỉ kế thừa được một Abstract Class duy nhất.Một lớp có thể "implement" nhiều Interface cùng lúc thông qua đa kế thừa.Trạng thái (State)Có thể lưu trữ các thuộc tính trạng thái (self.attribute).Thường không chứa trạng thái (chỉ tập trung vào hành vi).

4. Best Practices: Khi nào nên dùng cái nào?

Hãy chọn Abstract Class khi:
Bạn muốn chia sẻ code chung (các biến, hàm tiện ích) cho các lớp có họ hàng gần (Dog và Cat cùng kế thừa từ Animal).
Bạn muốn kiểm soát thứ tự khởi tạo hoặc dùng chung các constructor (__init__).
Hãy chọn Interface khi:
Bạn muốn áp dụng các hành vi rời rạc cho các lớp không có họ hàng với nhau (Ví dụ: Cả Invoice và Report đều cần tính năng Exportable).
Bạn muốn thiết kế hệ thống theo hướng Loose Coupling (Lỏng lẻo, dễ thay thế module sau này).

🟧 BỔ SUNG: KIẾN THỨC NÂNG CAO & AN TOÀN

Giới hạn kế thừa với Private Attributes

Để ngăn lớp con truy cập hoặc sửa đổi trực tiếp các dữ liệu nhạy cảm từ lớp cha, hãy sử dụng dấu gạch dưới kép (__) để tạo thuộc tính riêng tư (Private):

class Employee:
    def __init__(self, name: str, salary: float):
        self.name = name
        self.__salary = salary  # Private attribute

    def get_salary(self) -> float:
        return self.__salary

Tránh lạm dụng: Kế thừa ("IS-A") vs. Thành phần ("HAS-A")

Kế thừa ("IS-A"): Dùng khi thực sự tồn tại quan hệ bao hàm chặt chẽ.
Đóng gói / Thành phần ("HAS-A"): Dùng khi một lớp chứa một đối tượng của lớp khác để tận dụng tính năng mà không làm phức tạp hóa cây phân cấp lớp.
Ví dụ: Một Car (Xe hơi) có một Engine (Động cơ). Thay vì kế thừa từ Engine, ta nên khởi tạo đối tượng Engine bên trong lớp Car:
Python

class Engine:
    def start(self):
        print("Engine started!")

class Car:
    def __init__(self):
        self.engine = Engine()  # Quan hệ HAS-A (Thành phần)

    def start_car(self):
        self.engine.start()

📌 Lời Kết

Sử dụng thành thạo Abstract Class và Interface sẽ giúp bạn nâng tầm tư duy thiết kế hệ thống, viết code sạch, dễ mở rộng và tuân thủ các nguyên tắc SOLID trong lập trình hiện đại.

Từ khóa tìm kiếm: Abstract Base Class Python, Python Interface, abc module Python, OOP Best Practices.