Python 类的继承

1. 什么是类的继承

类的继承是面向对象编程中的一种重要概念和特性。通过继承，一个类可以从另一个类继承属性和方法，使得代码的复用更加方便和灵活。

在Python中，继承通过定义一个新的类，并在其定义中指定已存在的类，从而实现继承。被继承的类称为父类或基类，新定义的类称为子类或派生类。

继承的基本语法如下：

class 子类名(父类名):
    # 子类属性和方法的定义
    ...

2. 单继承

在Python中，一个子类可以继承自一个父类。这种继承关系被称为单继承。

下面是一个简单的示例，演示了单继承的基本用法：

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

    def speak(self):
        print("动物在叫")

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

    def speak(self):
        print("猫在喵喵叫")

cat = Cat("Tom", 3)
print(cat.name)  # 输出：Tom
print(cat.age)  # 输出：3
cat.speak()  # 输出：猫在喵喵叫

运行结果：

Tom
3
猫在喵喵叫

在上面的示例中，我们定义了两个类：Animal 和 Cat。Cat 类继承自 Animal 类。

Animal 类有一个构造方法 __init__ 和一个方法 speak。Cat 类也有一个构造方法 __init__ 和一个方法 speak。在 Cat 类的构造方法中，我们通过 super().__init__(name) 调用父类的构造方法，从而初始化父类的属性。在 Cat 类的 speak 方法中，我们通过重写父类的 speak 方法，实现了猫的叫声。

3. 多继承

除了单继承，Python 还支持多继承，即一个子类可以同时继承多个父类。多继承的语法如下：

class 子类名(父类1, 父类2, ...):
    # 子类属性和方法的定义
    ...

下面是一个示例，演示了多继承的用法：

class Parent1:
    def __init__(self, name1):
        self.name1 = name1

    def greet(self):
        print("Parent1: 你好，我是{}".format(self.name1))

class Parent2:
    def __init__(self, name2):
        self.name2 = name2

    def greet(self):
        print("Parent2: 你好，我是{}".format(self.name2))

class Child(Parent1, Parent2):
    def __init__(self, name1, name2, name3):
        Parent1.__init__(self, name1)
        Parent2.__init__(self, name2)
        self.name3 = name3

    def greet(self):
        print("Child: 你好，我是{}".format(self.name3))
        super().greet()

child = Child("张三", "李四", "王五")
print(child.name1)  # 输出：张三
print(child.name2)  # 输出：李四
print(child.name3)  # 输出：王五
child.greet()

运行结果：

张三
李四
王五
Child: 你好，我是王五
Parent1: 你好，我是张三

在上面的示例中，我们定义了三个类：Parent1、Parent2 和 Child。Child 类同时继承了 Parent1 和 Parent2 两个父类。

Parent1 和 Parent2 类中都有一个构造方法 __init__ 和一个方法 greet。Child 类的构造方法中，我们分别通过调用两个父类的构造方法，初始化两个父类的属性。在 Child 类的 greet 方法中，我们通过重写父类的 greet 方法，实现了子类自己的问候方式，并通过 super().greet() 调用父类的 greet 方法。

4. 方法的重写

子类可以通过重写（覆盖）父类的方法，来实现自己的方法逻辑。这种行为被称为方法的重写。

以下是一个简单示例：

class Shape:
    def area(self):
        pass

    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

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

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

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

    def area(self):
        return 3.14 * self.radius * self.radius

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

rectangle = Rectangle(5, 3)
print(rectangle.area())  # 输出：15
print(rectangle.perimeter())  # 输出：16

circle = Circle(4)
print(circle.area())  # 输出：50.24
print(circle.perimeter())  # 输出：25.12

运行结果：

在上面的示例中，我们定义了两个类：Shape（形状）和 Rectangle（矩形）以及 Circle（圆）。

Shape 类定义了两个抽象方法 area（面积）和 perimeter（周长）。Rectangle 类和 Circle 类分别继承了 Shape 类，并分别重写了 area 和 perimeter 方法，实现了矩形和圆的特定计算逻辑。

5. super() 函数

在子类中，可以使用 super() 函数调用父类的方法和属性。使用 super() 函数可以非常方便地在子类中调用父类的方法，避免了重复编写相似的代码。

以下是一个示例：

class A:
    def greet(self):
        print("Hello from class A")

class B(A):
    def greet(self):
        super().greet()
        print("Hello from class B")

b = B()
b.greet()