Kế thừa (Inheritance)

Inheritance là gì?

Inheritance (Kế thừa) là khả năng tạo một class mới (class con) dựa trên class đã có (class cha). Class con sẽ:

• Thừa hưởng tất cả thuộc tính và phương thức từ class cha
• Có thể thêm thuộc tính và phương thức mới
• Có thể ghi đè (override) phương thức của class cha

Tại sao cần Inheritance?

1. Tái sử dụng code (Code Reusability)

Không cần viết lại code đã có, chỉ cần kế thừa.

2. Mở rộng chức năng

Dễ dàng thêm tính năng mới mà không làm thay đổi code cũ.

3. Tổ chức code tốt hơn

Tạo cấu trúc phân cấp logic, dễ hiểu và bảo trì.

4. Polymorphism

Hỗ trợ đa hình - một trong những trụ cột của OOP.

Cú pháp

class ParentClass:
    # Code của class cha
    pass

class ChildClass(ParentClass):
    # Class con kế thừa từ class cha
    pass

Ví dụ cơ bản

# Class cha (Parent/Base/Super class)
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} đang phát ra tiếng kêu")

    def move(self):
        print(f"{self.name} đang di chuyển")

# Class con (Child/Derived/Sub class)
class Dog(Animal):
    def bark(self):
        print(f"{self.name} sủa: Gâu gâu!")

class Cat(Animal):
    def meow(self):
        print(f"{self.name} kêu: Meo meo!")

# Sử dụng
dog = Dog("Buddy")
dog.speak()  # Kế thừa từ Animal: Buddy đang phát ra tiếng kêu
dog.move()   # Kế thừa từ Animal: Buddy đang di chuyển
dog.bark()   # Phương thức riêng: Buddy sủa: Gâu gâu!

cat = Cat("Kitty")
cat.speak()  # Kitty đang phát ra tiếng kêu
cat.meow()   # Kitty kêu: Meo meo!

Kiểm tra quan hệ kế thừa

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

# Kiểm tra instance
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True

# Kiểm tra subclass
print(issubclass(Dog, Animal))  # True
print(issubclass(Animal, Dog))  # False

Constructor trong Inheritance

Cách 1: Không gọi constructor của class cha

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Student(Person):
    def __init__(self, name, age, student_id):
        # Gọi constructor của class cha
        Person.__init__(self, name, age)
        # Thêm thuộc tính mới
        self.student_id = student_id

student = Student("An", 20, "SV001")
print(f"{student.name}, {student.age} tuổi, MSV: {student.student_id}")

Cách 2: Dùng super() (Khuyến nghị)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Student(Person):
    def __init__(self, name, age, student_id, gpa):
        super().__init__(name, age)  # Gọi constructor của class cha
        self.student_id = student_id
        self.gpa = gpa

    def display_info(self):
        print(f"Sinh viên: {self.name}")
        print(f"Tuổi: {self.age}")
        print(f"MSV: {self.student_id}")
        print(f"GPA: {self.gpa}")

student = Student("Bình", 21, "SV002", 3.5)
student.display_info()

Method Overriding (Ghi đè phương thức)

Class con có thể định nghĩa lại phương thức của class cha.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} phát ra tiếng kêu")

class Dog(Animal):
    def speak(self):  # Override phương thức speak()
        print(f"{self.name} sủa: Gâu gâu!")

class Cat(Animal):
    def speak(self):  # Override phương thức speak()
        print(f"{self.name} kêu: Meo meo!")

class Bird(Animal):
    def speak(self):  # Override phương thức speak()
        print(f"{self.name} hót: Chip chip!")

# Test
animals = [Dog("Buddy"), Cat("Kitty"), Bird("Tweety")]
for animal in animals:
    animal.speak()
# Buddy sủa: Gâu gâu!
# Kitty kêu: Meo meo!
# Tweety hót: Chip chip!

Gọi phương thức của class cha với super()

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

    def display_info(self):
        print(f"Nhân viên: {self.name}")
        print(f"Lương: {self.salary:,}đ")

class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)
        self.department = department

    def display_info(self):
        super().display_info()  # Gọi phương thức của class cha
        print(f"Bộ phận: {self.department}")

manager = Manager("Nguyễn Văn A", 20000000, "IT")
manager.display_info()
# Nhân viên: Nguyễn Văn A
# Lương: 20,000,000đ
# Bộ phận: IT

Multiple Inheritance (Đa kế thừa)

Python cho phép một class kế thừa từ nhiều class cha.

class Flyable:
    def fly(self):
        print("Tôi có thể bay!")

class Swimmable:
    def swim(self):
        print("Tôi có thể bơi!")

class Duck(Flyable, Swimmable):
    def __init__(self, name):
        self.name = name

    def quack(self):
        print(f"{self.name}: Quack quack!")

duck = Duck("Donald")
duck.fly()    # Tôi có thể bay!
duck.swim()   # Tôi có thể bơi!
duck.quack()  # Donald: Quack quack!

Method Resolution Order (MRO)

Khi có đa kế thừa, Python dùng MRO để quyết định thứ tự tìm kiếm phương thức.

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

d = D()
d.show()  # B (tìm theo thứ tự: D -> B -> C -> A)

# Xem MRO
print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
#  <class '__main__.A'>, <class 'object'>)

Ví dụ thực tế: Hệ thống quản lý phương tiện

class Vehicle:
    """Class cha cho tất cả phương tiện"""
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
        self.mileage = 0

    def drive(self, distance):
        self.mileage += distance
        print(f"Đã di chuyển {distance}km. Tổng: {self.mileage}km")

    def display_info(self):
        print(f"{self.year} {self.brand} {self.model}")
        print(f"Quãng đường: {self.mileage}km")

class Car(Vehicle):
    """Xe hơi"""
    def __init__(self, brand, model, year, num_doors):
        super().__init__(brand, model, year)
        self.num_doors = num_doors

    def display_info(self):
        super().display_info()
        print(f"Số cửa: {self.num_doors}")

class Motorcycle(Vehicle):
    """Xe máy"""
    def __init__(self, brand, model, year, engine_cc):
        super().__init__(brand, model, year)
        self.engine_cc = engine_cc

    def display_info(self):
        super().display_info()
        print(f"Dung tích: {self.engine_cc}cc")

    def wheelie(self):
        print("Đang bốc đầu!")

class ElectricCar(Car):
    """Xe điện"""
    def __init__(self, brand, model, year, num_doors, battery_capacity):
        super().__init__(brand, model, year, num_doors)
        self.battery_capacity = battery_capacity
        self.battery_level = 100

    def charge(self, percent):
        self.battery_level = min(100, self.battery_level + percent)
        print(f"Đã sạc. Pin hiện tại: {self.battery_level}%")

    def drive(self, distance):
        battery_used = distance * 0.2  # Giả sử 1km tốn 0.2% pin
        if self.battery_level >= battery_used:
            super().drive(distance)
            self.battery_level -= battery_used
            print(f"Pin còn: {self.battery_level:.1f}%")
        else:
            print("Pin không đủ!")

    def display_info(self):
        super().display_info()
        print(f"Dung lượng pin: {self.battery_capacity}kWh")
        print(f"Mức pin: {self.battery_level}%")

# Sử dụng
print("=== XE HƠI ===")
car = Car("Toyota", "Camry", 2024, 4)
car.drive(100)
car.display_info()

print("\n=== XE MÁY ===")
bike = Motorcycle("Honda", "Wave", 2023, 110)
bike.drive(50)
bike.wheelie()
bike.display_info()

print("\n=== XE ĐIỆN ===")
tesla = ElectricCar("Tesla", "Model 3", 2024, 4, 75)
tesla.drive(200)
tesla.charge(30)
tesla.display_info()

Levels of Inheritance (Cấp độ kế thừa)

Single Inheritance (Đơn kế thừa)

class A:
    pass

class B(A):  # B kế thừa từ A
    pass

Multilevel Inheritance (Kế thừa nhiều cấp)

class A:
    pass

class B(A):  # B kế thừa từ A
    pass

class C(B):  # C kế thừa từ B
    pass

Hierarchical Inheritance (Kế thừa phân cấp)

class A:
    pass

class B(A):  # B kế thừa từ A
    pass

class C(A):  # C kế thừa từ A
    pass

Multiple Inheritance (Đa kế thừa)

class A:
    pass

class B:
    pass

class C(A, B):  # C kế thừa từ cả A và B
    pass

Ví dụ: Hệ thống nhân viên

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Tôi là {self.name}, {self.age} tuổi")

class Employee(Person):
    def __init__(self, name, age, employee_id, salary):
        super().__init__(name, age)
        self.employee_id = employee_id
        self.salary = salary

    def work(self):
        print(f"{self.name} đang làm việc")

    def get_salary(self):
        return self.salary

class Developer(Employee):
    def __init__(self, name, age, employee_id, salary, programming_languages):
        super().__init__(name, age, employee_id, salary)
        self.programming_languages = programming_languages

    def code(self):
        langs = ", ".join(self.programming_languages)
        print(f"{self.name} đang code bằng {langs}")

    def work(self):  # Override
        self.code()

class Manager(Employee):
    def __init__(self, name, age, employee_id, salary, team_size):
        super().__init__(name, age, employee_id, salary)
        self.team_size = team_size

    def manage(self):
        print(f"{self.name} đang quản lý {self.team_size} người")

    def work(self):  # Override
        self.manage()

# Sử dụng
dev = Developer("An", 25, "DEV001", 15000000, ["Python", "JavaScript"])
dev.introduce()  # Tôi là An, 25 tuổi
dev.work()       # An đang code bằng Python, JavaScript

manager = Manager("Bình", 35, "MNG001", 25000000, 10)
manager.introduce()  # Tôi là Bình, 35 tuổi
manager.work()       # Bình đang quản lý 10 người

print(f"Lương Dev: {dev.get_salary():,}đ")
print(f"Lương Manager: {manager.get_salary():,}đ")

Abstract Base Class (ABC)

Class trừu tượng - class không thể tạo object trực tiếp, chỉ dùng để kế thừa.

from abc import ABC, abstractmethod

class Shape(ABC):
    """Class trừu tượng"""
    def __init__(self, color):
        self.color = color

    @abstractmethod
    def area(self):
        """Phương thức trừu tượng - bắt buộc class con phải implement"""
        pass

    @abstractmethod
    def perimeter(self):
        pass

    def display_color(self):
        print(f"Màu sắc: {self.color}")

class Rectangle(Shape):
    def __init__(self, width, height, color):
        super().__init__(color)
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius, color):
        super().__init__(color)
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# shape = Shape("Đỏ")  # Lỗi! Không thể tạo instance của ABC

rect = Rectangle(5, 3, "Xanh")
print(f"Diện tích: {rect.area()}")  # 15
print(f"Chu vi: {rect.perimeter()}")  # 16
rect.display_color()  # Màu sắc: Xanh

circle = Circle(5, "Đỏ")
print(f"Diện tích: {circle.area():.2f}")  # 78.54
print(f"Chu vi: {circle.perimeter():.2f}")  # 31.42
circle.display_color()  # Màu sắc: Đỏ

Tổng kết

• Inheritance cho phép tái sử dụng và mở rộng code
• Class con thừa hưởng thuộc tính và phương thức từ class cha
• Dùng super() để gọi constructor và phương thức của class cha
• Method overriding cho phép class con định nghĩa lại phương thức
• Python hỗ trợ multiple inheritance (đa kế thừa)
• Abstract Base Class định nghĩa interface bắt buộc các class con phải implement

Trong bài tiếp theo, chúng ta sẽ tìm hiểu về Encapsulation (Đóng gói)!