Python继承案例如何子类继承父类

本文目录导读：

1. 基本继承案例
2. 多层继承
3. 多重继承
4. 使用super()的高级用法
5. 实战案例：员工管理系统
6. 继承的注意事项

我来为你详细讲解Python继承的案例,包括基本继承和多种继承方式。

基本继承案例

# 父类（基类）
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def eat(self):
        print(f"{self.name}正在吃东西")
    def sleep(self):
        print(f"{self.name}正在睡觉")
    def info(self):
        return f"名字：{self.name}，年龄：{self.age}"
# 子类（派生类）
class Dog(Animal):
    def __init__(self, name, age, breed):
        # 调用父类的构造方法
        super().__init__(name, age)
        self.breed = breed
    # 子类特有的方法
    def bark(self):
        print(f"{self.name}正在汪汪叫")
    # 重写父类的方法
    def eat(self):
        print(f"{self.name}正在吃狗粮")
# 使用示例
dog = Dog("旺财", 3, "金毛")
print(dog.info())      # 调用继承的方法
dog.eat()              # 调用重写的方法
dog.sleep()            # 调用继承的方法
dog.bark()             # 调用子类特有的方法

多层继承

# 基础父类
class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    def start(self):
        print("车辆启动")
    def stop(self):
        print("车辆停止")
# 中间父类
class Car(Vehicle):
    def __init__(self, brand, model, doors):
        super().__init__(brand, model)
        self.doors = doors
    def honk(self):
        print("按喇叭：嘀嘀")
# 子类（继承 Car，间接继承 Vehicle）
class ElectricCar(Car):
    def __init__(self, brand, model, doors, battery_capacity):
        super().__init__(brand, model, doors)
        self.battery_capacity = battery_capacity
    def charge(self):
        print(f"{self.brand} {self.model}正在充电")
    # 重写父类方法
    def start(self):
        print("电动车静音启动")
# 使用示例
tesla = ElectricCar("Tesla", "Model 3", 4, "75kWh")
tesla.start()          # 调用重写的方法
tesla.honk()           # 继承自 Car
tesla.charge()         # 子类特有的方法
tesla.stop()           # 继承自 Vehicle

多重继承

# 多个父类
class Flyable:
    def fly(self):
        print("正在飞行")
    def land(self):
        print("正在降落")
class Swimmable:
    def swim(self):
        print("正在游泳")
    def dive(self):
        print("正在潜水")
# 多重继承
class Duck(Flyable, Swimmable):
    def __init__(self, name):
        self.name = name
    def quack(self):
        print(f"{self.name}在嘎嘎叫")
# 使用示例
duck = Duck("唐老鸭")
duck.fly()      # 继承自 Flyable
duck.swim()     # 继承自 Swimmable
duck.quack()    # 子类自己的方法
# 方法解析顺序（MRO）
print(Duck.__mro__)  # 查看继承顺序

使用super()的高级用法

class Base:
    def __init__(self):
        print("Base.__init__")
class A(Base):
    def __init__(self):
        super().__init__()
        print("A.__init__")
class B(Base):
    def __init__(self):
        super().__init__()
        print("B.__init__")
class C(A, B):
    def __init__(self):
        super().__init__()
        print("C.__init__")
# C 的实例化会按照 MRO 顺序调用所有父类的 __init__
c = C()
print(C.__mro__)

实战案例：员工管理系统

class Employee:
    """基础员工类"""
    def __init__(self, name, employee_id, salary):
        self.name = name
        self.employee_id = employee_id
        self.salary = salary
    def work(self):
        print(f"{self.name}正在工作")
    def get_salary(self):
        return self.salary
    def info(self):
        return f"员工：{self.name}，工号：{self.employee_id}"
class Developer(Employee):
    """程序员子类"""
    def __init__(self, name, employee_id, salary, programming_languages):
        super().__init__(name, employee_id, salary)
        self.languages = programming_languages
    def work(self):
        print(f"{self.name}正在编写{self.languages}代码")
    def code_review(self):
        print(f"{self.name}正在进行代码审查")
class Manager(Employee):
    """经理子类"""
    def __init__(self, name, employee_id, salary, team_size):
        super().__init__(name, employee_id, salary)
        self.team_size = team_size
        self.team_members = []
    def work(self):
        print(f"{self.name}正在管理团队")
    def add_member(self, employee):
        self.team_members.append(employee)
        print(f"{employee.name}已加入{self.name}的团队")
class SeniorDeveloper(Developer, Manager):
    """高级程序开发员（多重继承示例）"""
    def __init__(self, name, employee_id, salary, languages, team_size):
        # 调用第一个父类的构造方法
        Developer.__init__(self, name, employee_id, salary, languages)
        Manager.__init__(self, name, employee_id, salary, team_size)
    def work(self):
        print(f"{self.name}既是高级开发人员，也是团队管理者")
        Developer.work(self)
        Manager.work(self)
# 使用示例
dev = Developer("张三", "D001", 15000, ["Python", "Java"])
mgr = Manager("李四", "M001", 25000, 5)
senior = SeniorDeveloper("王五", "S001", 35000, ["Python", "Go"], 8)
# 测试继承
dev.work()
print(dev.info())
print(f"薪资：{dev.get_salary()}")
mgr.work()
mgr.add_member(dev)
senior.work()
senior.code_review()  # 继承自 Developer
senior.add_member(dev)  # 继承自 Manager

继承的注意事项

class Parent:
    def __init__(self):
        print("Parent init")
        self.value = 100
    def common_method(self):
        print("Parent method")
class Child(Parent):
    def __init__(self):
        # 必须调用父类构造方法
        super().__init__()
        print("Child init")
        # 可以访问父类属性
        print(self.value)  # 100
    def common_method(self):
        # 调用父类方法
        super().common_method()
        print("Child method")
# 私有成员不会被继承
class BaseClass:
    def __init__(self):
        self.public = "公开"
        self._protected = "受保护的"  # 约定为保护成员
        self.__private = "私有的"     # 私有成员（名称修饰）
class SubClass(BaseClass):
    def access_members(self):
        print(self.public)      # 可以访问
        print(self._protected)  # 可以访问（但不推荐）
        # print(self.__private)  # 会报错！
# 测试
child = Child()
child.common_method()
sub = SubClass()
sub.access_members()
# 查看私有成员的名称修饰
print(dir(sub))

Python继承的关键点：

1. 语法：class Child(Parent):
2. 调用父类：使用 super().__init__() 或直接 Parent.__init__()
3. 方法重写：子类定义同名方法会覆盖父类方法
4. MRO：方法解析顺序决定多继承时的方法调用顺序
5. 私有成员：双下划线开头的属性不会被继承

继承能提高代码复用性，但要注意合理使用,避免过深的继承层次。