【小白讲python】十、函数的进阶

继承

• 继承是面向对象编程中的一个重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。
• 通过继承，子类可以获得父类的特性，并且可以在此基础上添加自己的特性或修改父类的特性。
  定义方法

class ParentClass:
    # 父类的属性和方法

class ChildClass(ParentClass):
    # 子类的属性和方法

单继承

• 单继承是指一个子类只能继承一个父类的属性和方法的继承方式。在单继承中，一个子类只能有一个直接的父类。
  例

class ParentClass:
    def parent_method(self):
        print("Parent method")

class ChildClass(ParentClass):
    def child_method(self):
        print("Child method")

parent = ParentClass()
parent.parent_method()  # 输出：Parent method

child = ChildClass()
child.parent_method()  # 输出：Parent method
child.child_method()  # 输出：Child method

多继承

• 多继承是指一个子类可以同时继承多个父类的属性和方法的继承方式。在多继承中，一个子类可以有多个直接的父类。
• 在Python中，多继承可以通过在类定义中指定多个父类来实现。子类可以继承多个父类的属性和方法，并且可以添加自己的属性和方法。

class ParentClass1:
    def parent_method1(self):
        print("Parent method 1")

class ParentClass2:
    def parent_method2(self):
        print("Parent method 2")

class ChildClass(ParentClass1, ParentClass2):
    def child_method(self):
        print("Child method")

child = ChildClass()
child.parent_method1()  # 输出：Parent method 1
child.parent_method2()  # 输出：Parent method 2
child.child_method()  # 输出：Child method

⼦类重写⽗类的同名属性和⽅法

• 子类可以重写父类的同名属性和方法。当子类重写父类的属性时，子类将拥有自己的属性值，而不是继承父类的属性值。当子类重写父类的方法时，子类将拥有自己的方法实现，而不是继承父类的方法实现。

class ParentClass:
    def __init__(self):
        self.property = "Parent property"

    def method(self):
        print("Parent method")

class ChildClass(ParentClass):
    def __init__(self):
        super().__init__()  # 调用父类的构造函数
        self.property = "Child property"  # 重写父类的属性

    def method(self):
        print("Child method")  # 重写父类的方法

child = ChildClass()
print(child.property)  # 输出：Child property
child.method()  # 输出：Child method

super()查找父类当中的方法

class ParentClass:
    def method(self):
        print("Parent method")

class ChildClass(ParentClass):
    def method(self):
        super().method()  # 调用父类的方法
        print("Child method")

child = ChildClass()
child.method()  # 输出 "Parent method" 和 "Child method"

面向对象的三大特征

面向对象编程（Object-Oriented Programming，简称OOP）有三大特征，分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

• 封装（Encapsulation）：封装是将数据和操作数据的方法封装在一起，形成一个类。通过封装，可以隐藏类的内部实现细节，只暴露必要的接口给外部使用。封装可以提高代码的可维护性和安全性，同时也方便了代码的复用。

• 继承（Inheritance）：继承是指一个类可以继承另一个类的属性和方法。通过继承，子类可以直接使用父类的属性和方法，而无需重新编写相同的代码。继承可以实现代码的重用和扩展，提高了代码的灵活性和可扩展性。

• 多态（Polymorphism）：多态是指同一个方法可以根据不同的对象调用出不同的行为。多态可以通过继承和接口实现。通过多态，可以编写出更加通用和灵活的代码，提高了代码的可读性和可维护性。

*这三大特征是面向对象编程的核心概念，它们使得代码更加模块化、可扩展和易于理解。通过合理运用封装、继承和多态，可以编写出高效、可复用和易于维护的代码。

# 封装（Encapsulation）
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

# 继承（Inheritance）
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def get_grade(self):
        return self.grade

# 多态（Polymorphism）
class Animal:
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Woof!"

class Cat(Animal):
    def sound(self):
        return "Meow!"

# 使用示例
person = Person("Alice", 25)
print(person.get_name())  # 输出：Alice
print(person.get_age())  # 输出：25

student = Student("Bob", 18, 12)
print(student.get_name())  # 输出：Bob
print(student.get_age())  # 输出：18
print(student.get_grade())  # 输出：12

dog = Dog()
print(dog.sound())  # 输出：Woof!

cat = Cat()
print(cat.sound())  # 输出：Meow!