Kế thừa trong Python

Category: Python

Kế thừa là một khái niệm cơ bản trong lập trình hướng đối tượng (OOP) cho phép một lớp (gọi là lớp con hoặc lớp dẫn xuất) kế thừa các thuộc tính và phương thức từ một lớp khác (gọi là lớp cha hoặc lớp cơ sở). Điều này thúc đẩy việc tái sử dụng mã, tính mô-đun và cấu trúc lớp phân cấp. Trong bài viết này, chúng ta sẽ khám phá tính kế thừa trong Python .

Ví dụ cơ bản về thừa kế

Kế thừa cho phép chúng ta định nghĩa một lớp kế thừa tất cả các phương thức và thuộc tính từ một lớp khác.

# Lớp cha
class Animal:
    def __init__(self, name):
        self.name = name  # Khởi tạo thuộc tính name

    def speak(self):
        pass  # Phương thức giữ chỗ sẽ được ghi đè bởi các lớp con

# Lớp con kế thừa từ lớp Animal
class Dog(Animal):
    def speak(self):
        return f"{self.name} sủa!"  # Ghi đè phương thức speak

# Tạo một đối tượng Dog
dog = Dog("Buddy")
print(dog.speak())

Đầu ra:

Buddy barks!

Giải thích:

  • Animal là lớp cha có phương thức init và phương thức speak.

  • Dog là lớp con kế thừa từ Animal.

  • Phương thức speak được ghi đè trong lớp Dog để cung cấp hành vi cụ thể.

Hãy cùng tìm hiểu chi tiết về thừa kế:

Mục lục

  • Cú pháp cho sự kế thừa

  • Giải thích cú pháp kế thừa của Python

  • Tạo một lớp cha

  • Tạo một lớp con

  • Hàm init()

  • hàm super()

  • Thêm Thuộc tính

  • Các loại kế thừa Python

Cú pháp cho sự kế thừa

class ParentClass:

    # Mã lớp cha ở đây 
    pass

class ChildClass(ParentClass):

    # Mã lớp con ở đây 
   pass

Giải thích cú pháp kế thừa của Python

  1. Lớp cha :

    • Đây là lớp cơ sở mà các lớp khác kế thừa.

    • Nó chứa các thuộc tính và phương thức mà lớp con có thể sử dụng lại.

  2. Lớp con:

    • Đây là lớp được kế thừa từ lớp cha.

    • Cú pháp để kế thừa là class ChildClass(ParentClass).

    • Lớp con sẽ tự động nhận được tất cả các thuộc tính và phương thức của lớp cha trừ khi bị ghi đè.

Tạo một lớp cha

Trong lập trình hướng đối tượng, lớp cha (còn được gọi là lớp cơ sở) định nghĩa các thuộc tính và phương thức chung có thể được các lớp khác kế thừa. Các thuộc tính và phương thức này đóng vai trò là nền tảng cho các lớp con. Bằng cách sử dụng tính kế thừa, các lớp con có thể truy cập và mở rộng chức năng do lớp cha cung cấp.

Sau đây là ví dụ trong đó Person là lớp cha:

# Một chương trình Python để minh họa kế thừa
class Person(object):

  # Hàm khởi tạo (Constructor)
  def __init__(self, name, id):
    self.name = name  # Thuộc tính tên
    self.id = id      # Thuộc tính ID

  # Phương thức để hiển thị thông tin người này
  def Display(self):
    print(self.name, self.id)


# Mã chính (Driver code)
emp = Person("Satyam", 102)  # Tạo một đối tượng thuộc lớp Person
emp.Display()  # Gọi phương thức hiển thị

Đầu ra

Satyam 102

Giải thích:

  • Lớp Person có hai thuộc tính: name và id. Chúng được thiết lập khi một đối tượng của lớp được tạo.

  • Phương pháp hiển thị sẽ in ra tên và ID của người đó.

Tạo một lớp con

Lớp con (còn được gọi là lớp dẫn xuất) là lớp kế thừa các thuộc tính và phương thức từ lớp cha của nó. Lớp con cũng có thể giới thiệu các thuộc tính và phương thức bổ sung, hoặc thậm chí ghi đè các thuộc tính và phương thức được kế thừa từ lớp cha.

Trong trường hợp này, Emp là lớp con kế thừa từ lớp Person:

class Emp(Person):
  
  def Print(self):
    print("Emp class called")
    
Emp_details = Emp("Mayank", 103)

# gọi hàm lớp cha
Emp_details.Display()

# gọi hàm lớp con
Emp_details.Print()

Giải thích:

  • Lớp Emp kế thừa các thuộc tính name và id và phương thức hiển thị từ lớp Person.

  • Phương thức init trong Emp gọi super().__init__(name, id) để gọi hàm tạo của lớp Person và khởi tạo các thuộc tính được kế thừa.

  • Emp giới thiệu một thuộc tính bổ sung, vai trò và cũng ghi đè phương thức hiển thị để in vai trò ngoài tên và id.

Hàm init()

Hàm init() là một phương thức khởi tạo trong Python. Nó khởi tạo trạng thái của đối tượng khi đối tượng được tạo. Nếu lớp con không định nghĩa phương thức init() của riêng mình, nó sẽ tự động kế thừa phương thức từ lớp cha.

Trong ví dụ trên, phương thức init() trong lớp Employee đảm bảo cả thuộc tính kế thừa và thuộc tính mới đều được khởi tạo đúng cách.

# Lớp cha: Người
class Person:
    def __init__(self, name, idnumber):
        self.name = name
        self.idnumber = idnumber

# Lớp con: Nhân viên
class Employee(Person):
    def __init__(self, name, idnumber, salary, post):
        super().__init__(name, idnumber)  # Gọi __init__() của Person
        self.salary = salary
        self.post = post

Giải thích:

  • Phương thức init() trong Person khởi tạo tên và idnumber.

  • Phương thức init() trong Employee gọi super().__init__(name, idnumber) để khởi tạo name và idnumber được thừa hưởng từ lớp Person và thêm salary và post.

hàm super()

Hàm super() được sử dụng để gọi các phương thức của lớp cha. Đặc biệt, nó thường được sử dụng trong phương thức init() của lớp con để khởi tạo các thuộc tính được kế thừa. Theo cách này, lớp con có thể tận dụng chức năng của lớp cha.

Ví dụ:

# Lớp cha: Người
class Person:
    def __init__(self, name, idnumber):
        self.name = name
        self.idnumber = idnumber

    def display(self):
        print(self.name)
        print(self.idnumber)

# Lớp con: Nhân viên
class Employee(Person):
    def __init__(self, name, idnumber, salary, post):
        super().__init__(name, idnumber)  # Sử dụng super() để gọi __init__() của Person
        self.salary = salary
        self.post = post

Giải thích:

  • Hàm super() được sử dụng bên trong phương thức init() của Employee để gọi hàm tạo của Person và khởi tạo các thuộc tính được kế thừa (name và idnumber).

  • Điều này đảm bảo rằng chức năng của lớp cha được tái sử dụng mà không cần phải viết lại mã trong lớp con.

Thêm Thuộc tính

Sau khi kế thừa được thiết lập, cả lớp cha và lớp con đều có thể có thuộc tính riêng. Thuộc tính là các thuộc tính thuộc về một lớp và được sử dụng để lưu trữ dữ liệu.

Ví dụ:

# Lớp cha: người
class Person:
    def __init__(self, name, idnumber):
        self.name = name
        self.idnumber = idnumber

    def display(self):
        print(self.name)
        print(self.idnumber)

# Lớp con: nhân viên
class Employee(Person):
    def __init__(self, name, idnumber, salary, post):
        super().__init__(name, idnumber)
        self.salary = salary
        self.post = post

Giải thích:

  • Lớp Person có các thuộc tính name và idnumber .

  • Lớp Nhân viên thêm các thuộc tính lương và chức vụ.

  • Các thuộc tính được khởi tạo khi một đối tượng được tạo và chúng biểu diễn dữ liệu cụ thể liên quan đến Người và Nhân viên.

Các loại kế thừa Python

  1. Kế thừa đơn : Một lớp con kế thừa từ một lớp cha.

  2. Kế thừa đa lớp : Một lớp con kế thừa từ nhiều lớp cha.

  3. Kế thừa đa cấp : Một lớp được kế thừa từ một lớp khác, lớp này cũng được kế thừa từ một lớp khác.

  4. Kế thừa phân cấp : Nhiều lớp kế thừa từ một lớp cha duy nhất.

  5. Kế thừa lai : Sự kết hợp của nhiều loại kế thừa.

Ví dụ:

# Lớp cha cơ bản
class Person:
    def __init__(self, name):
        self.name = name

# 1. Single Inheritance (Kế thừa đơn)
class Employee(Person):  # Employee kế thừa từ Person
    def __init__(self, name, salary):
        super().__init__(name)
        self.salary = salary

# 2. Multiple Inheritance (Kế thừa nhiều lớp)
class Job:
    def __init__(self, salary):
        self.salary = salary

class EmployeePersonJob(Employee, Job):  # Kế thừa từ Employee và Job
    def __init__(self, name, salary):
        Employee.__init__(self, name, salary)  # Gọi trực tiếp init của Employee
        Job.__init__(self, salary)            # Gọi trực tiếp init của Job

# 3. Multilevel Inheritance (Kế thừa đa cấp)
class Manager(EmployeePersonJob):  # Kế thừa từ EmployeePersonJob
    def __init__(self, name, salary, department):
        EmployeePersonJob.__init__(self, name, salary)
        self.department = department

# 4. Hierarchical Inheritance (Kế thừa phân cấp)
class AssistantManager(EmployeePersonJob):  # Cũng kế thừa từ EmployeePersonJob
    def __init__(self, name, salary, team_size):
        EmployeePersonJob.__init__(self, name, salary)
        self.team_size = team_size

# 5. Hybrid Inheritance (Kế thừa hỗn hợp = Multilevel + Multiple)
class SeniorManager(Manager, AssistantManager):  # Kế thừa từ 2 nhánh khác nhau
    def __init__(self, name, salary, department, team_size):
        Manager.__init__(self, name, salary, department)
        AssistantManager.__init__(self, name, salary, team_size)

# ---- Kiểm tra các kiểu kế thừa bằng cách tạo đối tượng ----

# 1. Single Inheritance
emp = Employee("John", 40000)
print("Single:", emp.name, emp.salary)

# 2. Multiple Inheritance
emp2 = EmployeePersonJob("Alice", 50000)
print("Multiple:", emp2.name, emp2.salary)

# 3. Multilevel Inheritance
mgr = Manager("Bob", 60000, "HR")
print("Multilevel:", mgr.name, mgr.salary, mgr.department)

# 4. Hierarchical Inheritance
asst_mgr = AssistantManager("Charlie", 45000, 10)
print("Hierarchical:", asst_mgr.name, asst_mgr.salary, asst_mgr.team_size)

# 5. Hybrid Inheritance
sen_mgr = SeniorManager("David", 70000, "Finance", 20)
print("Hybrid:", sen_mgr.name, sen_mgr.salary, sen_mgr.department, sen_mgr.team_size)

Đầu ra:

Single: John 40000
Multiple: Alice 50000
Multilevel: Bob 60000 HR
Hierarchical: Charlie 45000 10
Hybrid: David 70000 Finance 20

Giải thích:

  1. Kế thừa đơn: Nhân viên kế thừa từ Người, thêm thuộc tính lương.

  2. Kế thừa nhiều: EmployeePersonJob kế thừa từ cả Employee và Job, cho phép truy cập vào cả tên và lương.

  3. Kế thừa đa cấp: Manager kế thừa từ EmployeePersonJob, vốn đã bao gồm Employee và Job.

  4. Kế thừa theo thứ bậc : AssistantManager cũng kế thừa từ EmployeePersonJob, chứng minh nhiều lớp con kế thừa từ cùng một lớp cha.

  5. Kế thừa lai : SeniorManager kế thừa từ cả Manager (nhiều cấp) và AssistantManager (phân cấp), kết hợp hai kiểu kế thừa.

Published on Jun 19, 2025