类的三大特性：继承、封装、多态

一、前言
面向对象三大支柱：

继承：代码复用，子类拥有父类的属性和方法
封装：隐藏内部细节，只对外暴露必要接口
多态：不同子类重写父类方法，调用同一个方法表现不同行为

一、继承

1. 什么是继承

   父类（基类）：公共模板
   子类（派生类）：继承父类，拥有父类所有属性和方法，还能扩展自己的功能

语法格式

class 父类名:
    # 父类属性、方法

class 子类名(父类名):
    # 子类独有属性、方法

2. 基础继承示例

# 父类：人
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"我叫{self.name}，今年{self.age}岁")

# 子类：学生 继承 人
class Student(Person):
    pass

# 创建子类对象
s = Student("小樊", 20)
# 直接使用父类的方法
s.introduce()

3. 子类扩展自己的方法

class Student(Person):
    # 子类独有方法
    def study(self):
        print(f"{self.name} 正在学习Python")

s = Student("小樊", 20)
s.introduce()  # 父类方法
s.study()      # 子类自己方法

4. 子类重写父类方法
   子类有和父类同名方法，会覆盖父类：

class Student(Person):
    def introduce(self):
        print(f"学生：{self.name}，年龄{self.age}，在读编程")

5. super () 调用父类构造方法
   子类自己写 init 时，要用 super() 继承父类初始化：

class Student(Person):
    def __init__(self, name, age, stu_id):
        # 调用父类构造
        super().__init__(name, age)
        # 扩展自己属性
        self.stu_id = stu_id

    def introduce(self):
        print(f"学号：{self.stu_id}，姓名：{self.name}")

6. 多继承
   一个子类继承多个父类：

class A:
    pass

class B:
    pass

class C(A, B):
    pass

二、封装

1. 什么是封装

   把属性和方法封装在类内部
   隐藏内部敏感数据，不允许外部随意修改
   只通过提供的方法访问 / 修改数据

2. Python 私有属性（约定式）
   以两个下划线 __ 开头，变为私有，外部无法直接访问：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age   # 私有属性

直接访问会报错：

p = Person("小樊", 20)
# print(p.__age)  # 报错，外部无法直接访问

3. 提供公开方法访问 / 修改私有属性

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    # 获取私有属性
    def get_age(self):
        return self.__age

    # 修改私有属性，可加逻辑校验
    def set_age(self, new_age):
        if 0 < new_age < 150:
            self.__age = new_age
        else:
            print("年龄不合法")

使用：
```python
p = Person("小樊", 20)
print(p.get_age())
p.set_age(25)
p.set_age(200)  # 提示不合法

封装好处

保护数据安全，防止随意篡改
可以在修改时做数据校验
隐藏内部实现，对外接口统一

三、多态

1. 什么是多态

   父类定义统一接口
   多个子类重写该接口
   同一个方法，不同子类对象调用，表现不同行为

2. 多态代码示例

# 父类
class Animal:
    def speak(self):
        pass

# 子类1
class Dog(Animal):
    def speak(self):
        print("小狗汪汪叫")

# 子类2
class Cat(Animal):
    def speak(self):
        print("小猫喵喵叫")

# 多态函数
def animal_speak(animal: Animal):
    animal.speak()

# 传入不同子类对象，同一方法不同表现
dog = Dog()
cat = Cat()

animal_speak(dog)
animal_speak(cat)

运行结果：

小狗汪汪叫
小猫喵喵叫

多态核心

继承是多态的前提
子类重写父类方法
父类引用指向子类对象，自动调用子类重写的方法

四、三大特性总结

继承：复用代码，子类拥有父类功能并可扩展
封装：隐藏内部细节，私有属性 + 公开方法管控数据
多态：同一接口，不同子类实现不同行为，代码更灵活

五、练习题

1. 创建一个 Vehicle 父类，有 run() 方法。创建 Car 和 Bike 子类，重写 run() 方法。
2. 在 Car 类中添加私有属性 __fuel，使用 getter 和 setter 方法访问。
3. 实现一个函数，接受 Animal 对象列表，调用每个对象的 speak() 方法，展示多态。

六、本篇小结
面向对象编程通过继承、封装、多态三大特性，提高代码的可复用性、安全性和灵活性。掌握这些基础后，可以构建更复杂的程序结构。