Python Basics

Lập trình hướng đối tượng trong Python: kế thừa và đa hình

Đóng gói, kế thừa, ghi đè và đa hình, giải thích qua một ví dụ tài khoản ngân hàng chạy được ngay.

  • Cơ bản
  • Đọc trong 4 phút
  • 1 ví dụ chạy được
Bạn sẽ học được gì
  • Đóng gói bằng phương thức và thuộc tính bảo vệ
  • Kế thừa và super()
  • Ghi đè phương thức và đa hình
Cây kế thừa tài khoản
  • BankAccountbalance, deposit(), month_end()
    • BankAccountmonth_end(): "No interest"
    • SavingsAccountghi đè month_end(): cộng lãi
Một vòng lặp gọi account.month_end() cho mọi tài khoản mà không cần kiểm tra kiểu.

Lập trình hướng đối tượng trong Python là gì?

Vấn đề

Khi chương trình lớn dần, nhiều phần cần cùng một loại đối tượng (object) nhưng khác nhau đôi chút: tài khoản thường và tài khoản tiết kiệm, con mèo và con chó. Sao chép class rồi sửa vài dòng dẫn tới code trùng lặp, còn kiểm tra kiểu bằng if khắp nơi thì mỗi lần thêm loại mới lại phải sửa rất nhiều chỗ.

Hình dung đời thường

Lập trình hướng đối tượng vận hành giống các tài khoản trong cùng một ngân hàng. Tài khoản nào cũng giữ số dư phía sau quầy giao dịch (đóng gói). Tài khoản tiết kiệm là một tài khoản thường có thêm một tính năng (kế thừa). Khi ngân hàng báo đã đến cuối tháng cho mọi tài khoản, mỗi loại tự làm theo cách của mình (đa hình).

Từ ngân hàng đến code
self._balance🔒 Tiền nằm sau quầy: chỉ đổi được qua deposit()
class SavingsAccount(BankAccount):🏦 Tài khoản tiết kiệm là một tài khoản, cộng thêm lãi
super().__init__(owner, balance)📋 Điền mẫu tài khoản thường trước đã
account.month_end()📅 Cùng một yêu cầu, mỗi tài khoản trả lời theo cách riêng
Quy tắc chung nằm ở class cha, điểm khác biệt nằm ở class con.
Định nghĩa ngắn gọn

Lập trình hướng đối tượng (OOP) tổ chức chương trình thành các class, trong đó object giữ kín dữ liệu của mình (đóng gói, encapsulation), dùng lại class khác (kế thừa, inheritance) và phản hồi cùng một lời gọi theo cách riêng (đa hình, polymorphism).

Lập trình hướng đối tượng (OOP) mô hình hóa hệ thống bằng các đối tượng cộng tác với nhau. Mỗi đối tượng kết hợp trạng thái với các thao tác hợp lệ trên trạng thái đó, giúp chương trình lớn phân chia trách nhiệm rõ ràng hơn.

Bốn nguyên lý cốt lõi của OOP

  • Đóng gói: đặt trạng thái và hành vi liên quan cùng nhau, chỉ cho truy cập qua phương thức hoặc property được kiểm soát.
  • Trừu tượng: cung cấp giao diện cần thiết và che giấu chi tiết triển khai mà bên gọi không cần biết.
  • Kế thừa: tạo lớp chuyên biệt từ lớp có sẵn khi giữa chúng thực sự có quan hệ is-a.
  • Đa hình: gọi cùng một thao tác trên nhiều loại đối tượng và mỗi loại thực hiện hành vi phù hợp.

Thiết kế của ví dụ

  1. BankAccount sở hữu trạng thái số dư và kiểm tra khoản tiền nạp.
  2. SavingsAccount tái sử dụng hợp đồng của lớp tài khoản cơ sở qua kế thừa.
  3. SavingsAccount ghi đè month_end để cộng lãi.
  4. Vòng lặp xử lý mọi tài khoản qua cùng một giao diện.
Gợi ý thiết kế: Ưu tiên composition khi một đối tượng chỉ sử dụng đối tượng khác. Chỉ dùng kế thừa khi có thể thay lớp cha bằng lớp con mà chương trình vẫn đúng.

Khi nào nên sử dụng?

  • Nhiều loại object có phần lớn hành vi giống nhau: các loại tài khoản, hình học, nhân vật game.
  • Code phải làm việc được với các loại mới sau này mà không cần viết lại.
  • Bảo vệ dữ liệu phải luôn hợp lệ, như số dư không bao giờ được âm.

Khi nào chưa cần

  • Script nhỏ chỉ có vài hàm: class và kế thừa chỉ thêm những cấu trúc bạn không cần đến.
  • Chuỗi kế thừa quá sâu (A kế thừa B, B kế thừa C, C kế thừa D): rất khó theo dõi, nên dùng composition (ghép các object lại với nhau).

Ví dụ cơ bản

Chạy code →
main.py
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = float(balance)

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self._balance += amount

    def month_end(self):
        return "No interest"


class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def month_end(self):
        self._balance *= 1 + self.interest_rate
        return "Interest applied"


accounts = [
    BankAccount("Ada", 100),
    SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)

for account in accounts:
    status = account.month_end()
    print(f"{account.owner}: {account.balance:.2f} ({status})")
Lấy nút Run cho ví dụ này

Kết quả khi chạy

Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)

Thực hành bốn nguyên lý OOP

Các ví dụ tập trung sau minh họa cách Python thể hiện đóng gói, trừu tượng, kế thừa và đa hình trong code thực tế.

Đóng gói

Chạy code →

đặt trạng thái và hành vi liên quan cùng nhau, chỉ cho truy cập qua phương thức hoặc property được kiểm soát.

encapsulation.py
class BankAccount:
    def __init__(self, balance=0):
        # Double underscores prevent accidental direct access.
        self.__balance = balance

    @property
    def balance(self):
        # Expose read access without exposing mutation.
        return self.__balance

    def deposit(self, amount):
        # Keep validation next to the state it protects.
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.__balance += amount


account = BankAccount(100)
account.deposit(50)
print(account.balance)  # 150

Trừu tượng

Chạy code →

cung cấp giao diện cần thiết và che giấu chi tiết triển khai mà bên gọi không cần biết.

abstraction.py
from abc import ABC, abstractmethod


class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount):
        # Callers know what pay does, not how each provider does it.
        pass


class CreditCard(PaymentMethod):
    def pay(self, amount):
        # The concrete class hides its payment implementation.
        return f"Paid ${amount:.2f} by card"


payment = CreditCard()
print(payment.pay(25))

Kế thừa

Chạy code →

tạo lớp chuyên biệt từ lớp có sẵn khi giữa chúng thực sự có quan hệ is-a.

inheritance.py
class Employee:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return self.name


class Developer(Employee):
    def __init__(self, name, language):
        # Reuse initialization from the parent class.
        super().__init__(name)
        self.language = language

    def describe(self):
        # Extend inherited behavior instead of duplicating it.
        return f"{super().describe()} writes {self.language}"


print(Developer("Ada", "Python").describe())

Đa hình

Chạy code →

gọi cùng một thao tác trên nhiều loại đối tượng và mỗi loại thực hiện hành vi phù hợp.

polymorphism.py
class EmailNotification:
    def send(self, message):
        return f"Email: {message}"


class SmsNotification:
    def send(self, message):
        return f"SMS: {message}"


def notify(channels, message):
    for channel in channels:
        # The same call selects behavior from each concrete object.
        print(channel.send(message))


channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")

Giải thích code

Class BankAccount đóng gói số dư trong thuộc tính _balance và chỉ cho phép thay đổi qua các phương thức có kiểm tra như deposit(). Class SavingsAccount kế thừa toàn bộ các phương thức đó và ghi đè month_end() để cộng thêm tiền lãi. Vòng lặp gọi cùng một phương thức cho cả hai tài khoản, nhưng Python tự chọn phiên bản phù hợp với từng loại đối tượng khi chạy. Đó chính là đa hình.

Thay đổi giá trị và chạy chương trình bằng trình chạy Python online của CodeUtility mà không cần cài Python.

Bài tập mở rộng

Hãy thử chỉnh sửa code theo các gợi ý dưới đây. Tự thay đổi và quan sát kết quả sẽ giúp bạn hiểu bài sâu hơn nhiều so với chỉ đọc code.

  1. Thay đổi dữ liệu đầu vào và đoán trước kết quả rồi mới chạy để kiểm tra.
  2. Thêm phần kiểm tra cho trường hợp dữ liệu rỗng hoặc không hợp lệ.
  3. Đưa phần xử lý vào một hàm riêng và thử với nhiều bộ dữ liệu khác nhau.
Chạy trong trình biên dịch Python →

Lỗi hay gặp

Quên gọi super().__init__

Thiếu lời gọi này, phần khởi tạo của class cha không chạy và các thuộc tính như owner bị thiếu.

Sai
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Cách sửa
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        super().__init__(owner, balance)
        self.interest_rate = rate

Sửa trực tiếp dữ liệu được bảo vệ

Gán _balance từ bên ngoài sẽ bỏ qua các bước kiểm tra trong deposit().

Sai
account._balance = -500
Cách sửa
account.deposit(50)

Bạn học xong bài này chưa?

Đánh dấu đã học để theo dõi tiến độ của bạn.

Luyện tập với thử thách

Áp dụng kiến thức của bài học này để giải một bài toán thực tế. Mỗi thử thách chạy ngay trên trình duyệt, có kiểm thử tức thì và AI nhận xét.

Tất cả thử thách