1. 什么是继承？

继承是面向对象编程的四大支柱之一（其他三个是封装、抽象和多态）。它允许新创建的类（子类）继承现有类（父类）的属性和方法。

2. 创建子类的基本语法

在Python中创建子类非常简单，只需要在定义类时将父类放在括号中：

class ParentClass:
    def __init__(self, parent_attr):
        self.parent_attr = parent_attr
    
    def parent_method(self):
        return "This is a method from the parent class"

# 创建子类
class ChildClass(ParentClass):  # 继承ParentClass
    def __init__(self, parent_attr, child_attr):
        super().__init__(parent_attr)  # 调用父类的构造方法
        self.child_attr = child_attr
    
    def child_method(self):
        return "This is a method specific to the child class"

在这个例子中：

• ChildClass 继承自 ParentClass
• 子类的__init__方法中，我们使用super()调用了父类的构造方法
• 子类添加了新的属性child_attr和新方法child_method()

3. 方法重写（Method Overriding）

当子类需要改变从父类继承的方法行为时，可以重写该方法：

class Animal:
    def speak(self):
        return "Some generic animal sound"

class Dog(Animal):
    def speak(self):  # 重写父类的speak方法
        return "Woof!"

class Cat(Animal):
    def speak(self):  # 重写父类的speak方法
        return "Meow!"

# 测试
generic_animal = Animal()
print(generic_animal.speak())  # 输出: Some generic animal sound

my_dog = Dog()
print(my_dog.speak())          # 输出: Woof!

my_cat = Cat()
print(my_cat.speak())          # 输出: Meow!

方法重写是面向对象编程中实现多态性的关键机制。

4. 使用super()函数

super()函数用于调用父类的方法，在重写方法时特别有用：

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    
    def get_info(self):
        return f"{self.year} {self.make} {self.model}"

class ElectricCar(Vehicle):
    def __init__(self, make, model, year, battery_size):
        super().__init__(make, model, year)  # 调用父类的构造方法
        self.battery_size = battery_size  # 添加新属性
    
    # 重写父类方法，同时扩展新功能
    def get_info(self):
        # 调用父类的get_info方法
        vehicle_info = super().get_info()
        return f"{vehicle_info} with a {self.battery_size}-kWh battery"

# 创建实例
my_tesla = ElectricCar("Tesla", "Model S", 2023, 100)
print(my_tesla.get_info()) 
# 输出: 2023 Tesla Model S with a 100-kWh battery

5. 多重继承

Python支持多重继承，即一个类可以继承多个父类：

class Camera:
    def take_photo(self):
        print("Taking a photo")

class Phone:
    def make_call(self, number):
        print(f"Calling {number}")

# 多重继承
class SmartPhone(Camera, Phone):
    def browse_internet(self):
        print("Browsing the internet")

# 创建实例
my_phone = SmartPhone()
my_phone.take_photo()    # 来自Camera类
my_phone.make_call("123-456-7890")  # 来自Phone类
my_phone.browse_internet()  # SmartPhone自有方法

6. 多态性应用

多态性允许不同类的对象对同一消息做出不同响应：

class Shape:
    def area(self):
        pass  # 抽象方法

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

# 多态函数
def print_area(shape):
    print(f"The area is: {shape.area()}")

# 创建不同形状的实例
circle = Circle(5)
rectangle = Rectangle(4, 6)

# 调用相同的函数，但行为不同
print_area(circle)     # 输出: The area is: 78.5
print_area(rectangle)  # 输出: The area is: 24

多态性提高了代码的灵活性和可扩展性，允许添加新子类而不影响现有代码。

7. isinstance()和issubclass()函数

Python提供了两个内置函数用于检查类之间的关系：

class Animal: pass
class Dog(Animal): pass

my_dog = Dog()

print(isinstance(my_dog, Dog))    # True
print(isinstance(my_dog, Animal)) # True
print(isinstance(my_dog, object)) # True (所有类都继承自object)

class Animal: pass
class Dog(Animal): pass
class Bulldog(Dog): pass

print(issubclass(Dog, Animal))       # True
print(issubclass(Bulldog, Animal))   # True
print(issubclass(Bulldog, Dog))      # True
print(issubclass(Animal, Dog))       # False

8. 继承的最佳实践

为了创建健壮、可维护的继承结构，请遵循以下最佳实践：