子类调用父类方法

在 Python 中，子类可以通过内置函数 super() 来调用父类的方法。super() 函数提供了一种简单而强大的方式来访问父类的方法，并且确保方法解析顺序在多重继承的情况下是正确的。

下面是一个示例，演示了如何在子类中使用 super() 来调用父类的方法：

class Parent:
    def show(self):
        print("Inside Parent")

class Child(Parent):
    def show(self):
        super().show()  # 调用父类的方法
        print("Inside Child")

# 创建子类对象并调用方法
obj = Child()
obj.show()

在上面的示例中，Child 类中的 show 方法通过 super().show() 调用了父类 Parent 中的 show 方法。这样做的好处是，在多重继承的情况下，使用 super() 可以确保方法的调用顺序是正确的。

值得注意的是，super() 函数用于动态查找和调用同一方法的父类版本，而不需要显式指定父类的名称。这使得代码更加灵活，并且可以确保父类方法的调用顺序是正确的。

多态

在 Python 中，多态是面向对象编程中一个重要的概念，它允许不同类的对象对同一方法作出不同的响应。多态性使得同样的方法在不同的对象上能够有不同的行为。

下面是一个简单的示例，演示了如何在 Python 中使用多态：

class Cat:
    def sound(self):
        print("Meow!")

class Dog:
    def sound(self):
        print("Woof!")

class Cow:
    def sound(self):
        print("Moo!")

# 创建对象并调用方法
cat = Cat()
dog = Dog()
cow = Cow()

animals = [cat, dog, cow]  # 将不同的动物对象放到同一个列表中

for animal in animals:
    animal.sound()

在上面的示例中，Cat、Dog 和 Cow 类都包含一个名为 sound 的方法，但是每个类的 sound 方法返回不同的声音。通过将这些对象放到同一个列表中，并逐个调用它们的 sound 方法，我们可以看到它们会根据对象的类型表现出不同的行为，这就是多态的体现。

在 Python 中，多态性是默认行为，任何对象都可以根据需要表现出不同的行为。这种特性使得代码更加灵活，可以根据需要处理不同的对象，而不需要关心对象的具体类型。

封装

在 Python 中，类的封装是一种重要的面向对象编程概念，它允许将数据和方法包裹在类的内部，并控制对外部的访问。最常见的封装方式是使用属性和方法，并使用访问控制来限制对属性和方法的访问。

下面是一个简单的示例，演示了如何在 Python 中使用类的封装：

class Car:
    def __init__(self, brand, model):
        self._brand = brand  # 使用下划线作为前缀表示属性是受保护的
        self._model = model

    def get_brand(self):
        return self._brand

    def set_brand(self, brand):
        if type(brand) != str:
            raise ValueError("Brand must be a string")
        self._brand = brand

# 创建对象并访问封装的属性和方法
car = Car("Toyota", "Prius")
print(car.get_brand())  # 输出：Toyota

car.set_brand("Honda")
print(car.get_brand())  # 输出：Honda

在上面的示例中，我们创建了一个 Car 类，它包含了两个私有属性和相应的访问方法。属性前面的下划线 _ 表示属性是受保护的，建议外部代码不要直接访问它们，而是通过公共的访问方法来进行访问和修改。

通过封装，我们可以控制属性的访问和修改，从而确保数据的有效性和安全性。同时，封装还能带来更加清晰的代码结构和更佳的代码重用性。（补充单下划线的属性是约定的封装私有属性，而双下划线开始的才是真正的封装私有属性，类的外部是无法直接调用的）