乐趣区

关于人工智能:42-继承与多态

jiezi

继承和多态是面向对象编程的两个重要概念。继承容许创立一个新类，该类继承自现有类的属性和办法，从而实现代码重用和模块化。多态是指同一操作作用于不同的对象，能够产生不同的后果，它使得咱们能够应用对立的接口解决不同类型的对象。

4.2.1 继承

在 Python 中，要创立一个继承自现有类的新类，只需在类定义时将现有类名放在括号里。例如：

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

    def speak(self):
        print(f"{self.name}, a {self.species}, is speaking.")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "dog")

    def speak(self):
        print(f"{self.name}, a {self.species}, says Woof!")

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name, "cat")

    def speak(self):
        print(f"{self.name}, a {self.species}, says Meow!")

在这个示例中，咱们定义了一个 Animal 类，它具备两个属性 name 和 species，以及一个 speak() 办法。咱们还定义了两个继承自 Animal 类的子类：Dog 和 Cat。这两个子类别离笼罩了 speak() 办法，以实现特定于它们的行为。

4.2.2 多态

多态容许咱们应用雷同的接口解决不同类型的对象。以下是一个多态的示例：

def let_animals_speak(animals):
    for animal in animals:
        animal.speak()

dog1 = Dog("Buddy")
cat1 = Cat("Whiskers")

let_animals_speak([dog1, cat1])

在这个示例中，咱们定义了一个名为 let_animals_speak() 的函数，它接管一个动物列表作为参数，并调用列表中每个动物的 speak() 办法。咱们创立了一个 Dog 类的实例 dog1 和一个 Cat 类的实例 cat1，并将它们传递给 let_animals_speak() 函数。只管它们是不同类型的对象，但多态容许咱们应用雷同的接口解决它们。

输入后果为：

Buddy, a dog, says Woof!
Whiskers, a cat, says Meow!

4.2.3 办法重写（Override）

在子类中，能够笼罩（重写）基类中的办法，以实现特定于子类的性能。例如，在下面的示例中，Dog 和 Cat 子类别离重写了 Animal 类的 speak() 办法。

4.2.4 调用基类办法

在子类中，能够应用 super() 函数调用基类的办法。例如，当创立 Dog 或 Cat 类的实例时，咱们须要调用 Animal 类的 __init__() 办法来初始化 name 和 species 属性。在这种状况下，咱们能够应用 super().__init__(name, species) 调用基类的构造方法，如下：

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "dog")

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name, "cat")

4.2.5 多重继承

Python 反对多重继承，这意味着一个类能够从多个基类中继承属性和办法。要创立一个继承自多个基类的新类，只需在类定义时将这些基类名放在括号里，并用逗号分隔。例如：

class SwimMixin:
    def swim(self):
        print(f"{self.name} is swimming.")

class FlyMixin:
    def fly(self):
        print(f"{self.name} is flying.")

class Dolphin(Animal, SwimMixin):
    def __init__(self, name):
        super().__init__(name, "dolphin")

class Bat(Animal, FlyMixin):
    def __init__(self, name):
        super().__init__(name, "bat")

dolphin1 = Dolphin("Flipper")
bat1 = Bat("Dracula")

dolphin1.swim()
bat1.fly()

在这个示例中，咱们定义了两个混入类（Mixin）：SwimMixin 和 FlyMixin。混入类是一种罕用的多重继承模式，它们蕴含特定的行为，能够在其余类中重用。咱们创立了一个 Dolphin 类，同时从 Animal 类和 SwimMixin 类继承，还创立了一个 Bat 类，同时从 Animal 类和 FlyMixin 类继承。

当咱们创立 Dolphin 和 Bat 类的实例并调用它们的 swim() 和 fly() 办法时，输入后果为：

Flipper is swimming.
Dracula is flying.

至此，咱们曾经具体介绍了继承与多态的基本概念、办法重写、调用基类办法以及多重继承等知识点，并通过实例代码展现了它们的利用。心愿这些内容能帮忙你更好地了解 Python 面向对象编程中的继承与多态。
举荐浏览：

https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA

https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g

退出移动版