python进阶-Day2: 面向对象编程 (OOP)

以下是为 Python 进阶 Day 2 设计的学习任务，专注于面向对象编程（OOP）的核心概念和高阶特性。代码中包含详细注释，帮助理解每个部分的实现和目的。

任务目标：

1. 复习 OOP 基础：类、对象、继承、多态。
2. 学习高级 OOP 特性：@property 装饰器、抽象基类 (ABC)、方法解析顺序 (MRO)。
3. 练习：设计一个简单的“动物”类层次结构，综合应用所学内容。

学习任务设计：

1. 复习基础 OOP
2. 创建一个基类 Animal，并派生出子类 Dog 和 Cat，展示继承和多态。
3. 学习高级 OOP
4. 使用 @property 装饰器管理属性访问。
5. 使用抽象基类 (ABC) 强制子类实现特定方法。
6. 通过 mro() 方法探索方法解析顺序。
7. 练习
8. 实现一个动物类层次结构，包含属性管理和抽象方法。

代码实现（带详细注释）：

python

# 导入抽象基类模块
from abc import ABC, abstractmethod

# 任务 1：复习基础 OOP - 定义基类 Animal
class Animal:
    def __init__(self, name, age):
        self._name = name  # 受保护属性，使用单下划线
        self._age = age    # 受保护属性

    def speak(self):
        # 定义一个默认的 speak 方法，子类可以覆盖（多态）
        return "I can speak!"

    def get_info(self):
        # 返回动物的基本信息
        return f"Name: {self._name}, Age: {self._age}"


# 任务 1：继承与多态 - 定义子类 Dog
class Dog(Animal):
    def speak(self):
        # 多态：覆盖父类的 speak 方法
        return "Woof Woof!"


# 任务 1：继承与多态 - 定义子类 Cat
class Cat(Animal):
    def speak(self):
        # 多态：覆盖父类的 speak 方法
        return "Meow Meow!"


# 任务 2：学习 @property 装饰器 - 定义一个带属性管理的类
class Bird(Animal):
    def __init__(self, name, age, wingspan):
        super().__init__(name, age)  # 调用父类的构造函数
        self._wingspan = wingspan    # 私有属性，表示翼展

    @property
    def wingspan(self):
        # 使用 @property 装饰器，将 wingspan 作为只读属性
        return self._wingspan

    @wingspan.setter
    def wingspan(self, value):
        # 使用 @setter 控制 wingspan 的赋值，确保值有效
        if value <= 0:
            raise ValueError("Wingspan must be positive!")
        self._wingspan = value


# 任务 2：学习抽象基类 (ABC) - 定义抽象基类
class AbstractAnimal(ABC):
    @abstractmethod
    def move(self):
        # 抽象方法，子类必须实现
        pass

    def eat(self):
        # 普通方法，提供默认实现
        return "I am eating!"


# 任务 2：实现抽象基类的子类
class Fish(AbstractAnimal, Animal):  # 多重继承：从抽象基类和 Animal 继承
    def __init__(self, name, age):
        Animal.__init__(self, name, age)

    def move(self):
        # 实现抽象方法 move
        return "I swim in water!"

    def speak(self):
        # 覆盖 Animal 的 speak 方法
        return "Blub Blub!"


# 任务 3：综合练习 - 测试代码
def main():
    # 测试基础 OOP
    dog = Dog("Buddy", 3)
    cat = Cat("Whiskers", 2)
    print(dog.get_info())      # 输出: Name: Buddy, Age: 3
    print(dog.speak())         # 输出: Woof Woof!
    print(cat.get_info())      # 输出: Name: Whiskers, Age: 2
    print(cat.speak())         # 输出: Meow Meow!

    # 测试 @property 装饰器
    bird = Bird("Eagle", 5, 2.5)
    print(bird.get_info())     # 输出: Name: Eagle, Age: 5
    print(bird.wingspan)       # 输出: 2.5
    bird.wingspan = 3.0        # 使用 setter 修改 wingspan
    print(bird.wingspan)       # 输出: 3.0
    # bird.wingspan = -1       # 取消注释将抛出 ValueError

    # 测试抽象基类和多重继承
    fish = Fish("Nemo", 1)
    print(fish.get_info())     # 输出: Name: Nemo, Age: 1
    print(fish.move())         # 输出: I swim in water!
    print(fish.speak())        # 输出: Blub Blub!
    print(fish.eat())          # 输出: I am eating!

    # 任务 2：探索方法解析顺序 (MRO)
    print(Fish.mro())          # 输出 Fish 的方法解析顺序


if __name__ == "__main__":
    main()

学习任务分解与说明：

1. 复习 OOP 基础
2. Animal 类作为基类，定义了属性 _name 和 _age，以及方法 speak 和 get_info。
3. Dog 和 Cat 继承自 Animal，通过重写 speak 方法实现多态。
4. 高级 OOP：
5. @property
6. 装饰器
7. Bird 类使用 @property 和 @wingspan.setter 管理 wingspan 属性，确保属性访问的安全性和封装性。
8. 高级 OOP：抽象基类 (ABC)
9. AbstractAnimal 定义了一个抽象方法 move，子类 Fish 必须实现它。
10. 通过多重继承，Fish 同时继承了 AbstractAnimal 和 Animal 的功能。
11. 高级 OOP：方法解析顺序 (MRO)
12. 使用 Fish.mro() 查看类的继承顺序，帮助理解多重继承时的解析规则。
13. 综合练习
14. main() 函数测试所有功能，展示类层次结构的行为。

练习任务：

1. 修改 Animal 类，添加一个新属性（如 weight），并用 @property 管理它。
2. 创建一个新的子类（如 Snake），继承 AbstractAnimal 和 Animal，实现 move 和 speak 方法。
3. 尝试引发一个多重继承的冲突（如两个父类都有同名方法），并用 mro() 分析解析顺序。

这个设计涵盖了 OOP 的核心概念和高阶特性，通过注释和实践帮助深入理解 Python 的面向对象编程。