Bỏ qua đến nội dung chính
Mục lục

Ghi đè phương thức trong Python (method overriding)

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 10/17 · Chương 13

Lập trình hướng đối tượng

  • 8 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Ghi đè phương thức trong Python (method overriding) là việc class con viết lại một phương thức cùng tên với phương thức của class cha, để object của class con làm việc đó theo cách riêng. Bạn ghi đè khi class con cần đổi một phần hành vi đã thừa hưởng, như tài khoản tiết kiệm chỉ cho rút tối đa một nửa số dư, trong khi tài khoản thường rút được hết.

Cần biết trước: kế thừa và super().

Viết lại phương thức của class cha

Class con có một phương thức trùng tên với class cha thì Python dùng bản của class con, vì nó tìm tên trên class của object trước rồi mới lên class cha:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du

    def mo_ta(self):
        return f"{self.chu}: {self.so_du:,} đ"

class TaiKhoanTietKiem(TaiKhoan):
    def mo_ta(self):
        return f"Sổ tiết kiệm của {self.chu}: {self.so_du:,} đ"

print(TaiKhoan("Hà", 800000).mo_ta())
print(TaiKhoanTietKiem("Minh", 3000000).mo_ta())

KẾT QUẢ

Hà: 800,000 đ
Sổ tiết kiệm của Minh: 3,000,000 đ

Hai object gọi cùng một tên mo_ta() nhưng chạy hai thân khác nhau. Bản của class cha không bị xóa hay sửa: object tạo từ TaiKhoan vẫn dùng nó. Ghi đè giống dán một tờ giấy mới đè lên một trang của cuốn sổ mẫu: người đọc cuốn sổ của class con thấy tờ mới, cuốn sổ mẫu vẫn nguyên. Đổi "Sổ tiết kiệm của {self.chu} thành "TK {self.chu} rồi chạy lại: dòng thứ hai in TK Minh: 3,000,000 đ.

Mở rộng bản của cha bằng super()

Tài khoản tiết kiệm vẫn rút tiền như tài khoản thường, chỉ thêm một luật: không rút quá một nửa số dư. Thay vì chép lại phép trừ, phương thức ghi đè kiểm luật mới rồi giao phần còn lại cho bản của cha bằng super().rut(so_tien):

python
class TaiKhoan:
    def __init__(self, so_du):
        self.so_du = so_du
    def rut(self, so_tien):
        if so_tien <= self.so_du:
            self.so_du -= so_tien
        return self.so_du

class TaiKhoanTietKiem(TaiKhoan):
    def rut(self, so_tien):
        if so_tien * 2 > self.so_du:
            return self.so_du
        return super().rut(so_tien)

print(TaiKhoanTietKiem(3000000).rut(2000000))

KẾT QUẢ

3000000

2000000 lớn hơn một nửa của 3000000, nên bản của class con trả về số dư cũ mà không gọi tới cha. Khi số tiền qua được luật mới, super().rut(so_tien) chạy thân rut của TaiKhoan, và bản của con trả về đúng thứ bản của cha trả về. Kiểm thêm điều kiện rồi gọi super() là cách mở rộng; viết một thân mới không gọi super() như mo_ta() ở trên là cách thay hẳn. Đổi rut(2000000) thành rut(1500000) rồi chạy lại: dòng in 1500000, vì rút đúng một nửa vẫn được.

Ghi đè __str__ và gọi lại bản của cha

Phương thức nào cũng ghi đè được, kể cả __init__ của bài kế thừa và __str__ quyết định print() in gì. Tài khoản tiết kiệm in giống tài khoản thường rồi thêm lãi suất:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"

class TaiKhoanTietKiem(TaiKhoan):
    def __init__(self, chu, so_du, lai_suat):
        super().__init__(chu, so_du)
        self.lai_suat = lai_suat
    def __str__(self):
        return super().__str__() + f", lãi {self.lai_suat}%/năm"

print(TaiKhoanTietKiem("Minh", 10000000, 6))

KẾT QUẢ

Minh: 10,000,000 đ, lãi 6%/năm

super().__str__() trả về chuỗi do class cha dựng, và class con chỉ nối thêm phần của nó. Đổi định dạng tiền ở class cha thì tài khoản tiết kiệm đổi theo, khỏi sửa hai chỗ. Đổi TaiKhoanTietKiem("Minh", 10000000, 6) thành TaiKhoan("Minh", 10000000) rồi chạy lại: dòng in Minh: 10,000,000 đ, không có phần lãi.

Phương thức của cha gọi bản đã ghi đè

Một phương thức chỉ viết ở class cha mà gọi self.phi_rut() sẽ chạy bản phi_rut() của class mà object thuộc về. Tài khoản VIP chỉ ghi đè phí, còn rut() để nguyên ở class cha:

python
class TaiKhoan:
    def __init__(self, so_du):
        self.so_du = so_du
    def phi_rut(self):
        return 1100
    def rut(self, so_tien):
        self.so_du -= so_tien + self.phi_rut()
        return self.so_du

class TaiKhoanVip(TaiKhoan):
    def phi_rut(self):
        return 0

print(TaiKhoan(500000).rut(100000), TaiKhoanVip(500000).rut(100000))

KẾT QUẢ

398900 400000

Trong rut(), self là object đang gọi. Với tài khoản VIP, self.phi_rut tìm thấy bản của TaiKhoanVip trước, nên phí là 0 dù dòng gọi nằm trong class cha. Nhờ vậy class con đổi một chi tiết nhỏ mà không phải ghi đè cả phương thức lớn. Đổi return 0 thành return 550 rồi chạy lại: dòng in 398900 399450.

Kiểm tra nhanh

  1. Trong ví dụ tài khoản VIP, TaiKhoanVip(200000).rut(50000) trả về số nào?

    • 148900
    • 200000
    • 150000
  2. Phương thức rut của class con kết thúc bằng return self.rut(so_tien) để "dùng bản của cha". Điều gì xảy ra khi gọi nó với số tiền hợp lệ?

    • Bản rut của class cha chạy một lần
    • Báo lỗi RecursionError, vì phương thức tự gọi chính nó mãi
    • Python báo lỗi cú pháp ở dòng return
  3. Những câu nào đúng về ghi đè phương thức?

    • Ghi đè không làm đổi bản của class cha; object của class cha vẫn dùng bản cũ
    • Phương thức ghi đè phải gọi super(), nếu không Python báo lỗi
    • super().__str__() trả về chuỗi do bản của class cha dựng
    • Ghi đè chỉ làm được với __init__ và __str__
  4. Class con viết def Mo_ta(self): trong khi class cha có mo_ta(). Lời gọi tk.mo_ta() trên object của class con làm gì?

    • Chạy bản mo_ta() của class cha, không báo lỗi
    • Chạy bản Mo_ta() của class con
    • Báo lỗi AttributeError
Đúng hết lần đầu +15 XP

Bài tập

Ghi đè phép rút và phép in của sổ tiết kiệm

Class TaiKhoan có rut() ghi số tiền rút vào lich_su và __str__() in chủ cùng số dư. Trong class con TaiKhoanTietKiem, ghi đè hai phương thức:

  • rut(self, so_tien): số tiền lớn hơn một nửa số dư thì từ chối, trả về False, không đổi gì. Đúng một nửa hoặc ít hơn thì giao cho bản rut() của class cha và trả về thứ nó trả về.

  • __str__(self): chuỗi của class cha, nối thêm " (tiết kiệm)".

Dùng super() cho cả hai, không chép lại thân của class cha.

Trả về: rut() một bool, __str__() một str.

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
        self.lich_su = []
    def rut(self, so_tien):
        if so_tien > self.so_du:
            return False
        self.so_du -= so_tien
        self.lich_su.append(-so_tien)
        return True
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"

class TaiKhoanTietKiem(TaiKhoan):
    def rut(self, so_tien):
        pass  # Viết thân các phương thức thay cho các dòng pass
    def __str__(self):
        pass

Tóm tắt

  • Class con có phương thức trùng tên với class cha thì object của class con chạy bản của con: đó là ghi đè.

  • Ghi đè không đổi bản của class cha; object tạo từ class cha vẫn dùng bản cũ.

  • Thay hẳn thì viết thân mới; mở rộng thì kiểm thêm rồi gọi super().ten_phuong_thuc(...).

  • Gọi self.ten_phuong_thuc() trong chính phương thức ghi đè là tự gọi mình, dẫn tới RecursionError.

  • Tên lệch một ký tự thì không ghi đè gì, bản của cha vẫn chạy mà Python không báo.

  • Phương thức của class cha gọi self.x() sẽ chạy bản x() của class mà object thuộc về.

Câu hỏi thường gặp

Ghi đè (override) khác nạp chồng (overload) thế nào trong Python?

Override (ghi đè) là class con viết lại phương thức cùng tên của class cha. Overload (nạp chồng) là có nhiều bản cùng tên khác nhau ở số tham số, thứ Python không có sẵn: def sau cùng tên thay cho def trước. Bài nạp chồng phương thức chỉ các cách Python làm được việc giống như vậy.

Ghi đè phương thức có bắt buộc gọi super() không?

Không. Gọi super() khi bạn muốn giữ việc của class cha và thêm phần mới, như phép rút kiểm thêm hạn mức. Khi hành vi mới khác hẳn, như dòng mô tả sổ tiết kiệm, thân mới không cần super(). Riêng __init__ của class con gần như luôn gọi super().__init__(), như bài kế thừa giải thích.

Phương thức ghi đè có phải nhận đúng các tham số như bản của cha không?

Nên giữ cùng tham số, vì chỗ khác trong chương trình gọi phương thức đó theo cách của class cha. Class con bỏ mất tham số so_tien thì lời gọi tk.rut(500000) báo TypeError về số đối số. Thêm tham số mới thì cho nó giá trị mặc định.

Ghi đè phương thức giúp gì khi có nhiều loại tài khoản?

Ghi đè cho mỗi class một bản riêng của cùng một phương thức. Nhờ vậy một đoạn code gọi tk.mo_ta() trên nhiều loại tài khoản mà không cần hỏi từng cái thuộc class nào. Cách dùng đó gọi là đa hình, và bài đa hình ngay sau bài này dạy kỹ.

Chủ đề

method overriding python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập