哪些Python案例展示了面向对象编程？

wen python案例 2026-06-18 256

本文目录导读：

银行账户系统（封装 + 继承）
动物声音模拟（多态）
员工管理系统（组合 + 类方法）
图书馆借阅系统（综合案例）
OOP 核心概念总结表

银行账户系统（封装 + 继承）

class BankAccount:
    """基础银行账户类"""
    def __init__(self, account_number, owner, balance=0):
        self.account_number = account_number  # 公开属性
        self.owner = owner
        self.__balance = balance  # 私有属性（封装）
    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self.__balance += amount
            print(f"存款 {amount}，当前余额：{self.__balance}")
        else:
            print("存款金额必须为正数")
    def withdraw(self, amount):
        """取款（带验证）"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"取款 {amount}，当前余额：{self.__balance}")
        else:
            print("余额不足或金额无效")
    def get_balance(self):
        """获取余额（通过方法访问私有属性）"""
        return self.__balance
    def __str__(self):
        return f"{self.owner}的账户 [{self.account_number}], 余额：{self.__balance}"
# 继承：储蓄账户
class SavingsAccount(BankAccount):
    """储蓄账户（有最低余额限制和利息）"""
    def __init__(self, account_number, owner, balance=0, interest_rate=0.02):
        super().__init__(account_number, owner, balance)
        self.interest_rate = interest_rate
    def withdraw(self, amount):
        """重写取款方法，增加最低余额限制"""
        if self.get_balance() - amount < 100:  # 最低余额100元
            print("取款失败：余额不能低于100元")
        else:
            super().withdraw(amount)  # 调用父类方法
    def apply_interest(self):
        """应用利息"""
        interest = self.get_balance() * self.interest_rate
        self.deposit(interest)  # 直接使用父类的deposit
        print(f"利息 {interest:.2f} 已存入")
# 使用示例
savings = SavingsAccount("123456", "张三", 1000, 0.03)
savings.deposit(500)       # 存款 500，当前余额：1500
savings.withdraw(400)      # 取款 400，当前余额：1100
savings.withdraw(800)      # 取款失败：余额不能低于100元
savings.apply_interest()   # 利息 33.00 已存入
print(savings)             # 张三的账户 [123456], 余额：1133.0

OOP 特性展示：

封装：__balance 私有属性，通过公共方法访问
继承：SavingsAccount 继承 BankAccount
方法重写：withdraw 方法增强功能
super()：调用父类方法

动物声音模拟（多态）

from abc import ABC, abstractmethod
class Animal(ABC):
    """抽象基类"""
    def __init__(self, name):
        self.name = name
    @abstractmethod
    def make_sound(self):
        """抽象方法：子类必须实现"""
        pass
    def describe(self):
        """通用方法"""
        print(f"{self.name}是{self.__class__.__name__}")
class Dog(Animal):
    def make_sound(self):
        return "汪汪汪！"
    def fetch(self):
        print(f"{self.name}正在捡球")
class Cat(Animal):
    def make_sound(self):
        return "喵喵喵～"
    def purr(self):
        print(f"{self.name}在打呼噜")
class Duck(Animal):
    def make_sound(self):
        return "嘎嘎嘎！"
# 多态函数：传入任何Animal子类都能工作
def animal_concert(animals):
    for animal in animals:
        animal.describe()
        print(f"  - 声音：{animal.make_sound()}")
        print()
# 使用示例
animals = [
    Dog("旺财"),
    Cat("咪咪"),
    Duck("唐老鸭"),
    Dog("来福"),
]
animal_concert(animals)

OOP 特性展示：

抽象基类（ABC）：定义接口规范
多态：同一接口（make_sound）不同实现
鸭子类型：只要对象有 make_sound 方法就能使用

员工管理系统（组合 + 类方法）

class Department:
    """部门类（组合关系的基础）"""
    def __init__(self, name, manager=None):
        self.name = name
        self.manager = manager
        self.employees = []
    def add_employee(self, employee):
        self.employees.append(employee)
        print(f"{employee.name} 加入 {self.name}")
    def __str__(self):
        return f"部门：{self.name}，员工数：{len(self.employees)}"
class Employee:
    """员工类"""
    # 类变量（所有实例共享）
    company = "XX科技有限公司"
    employee_count = 0
    def __init__(self, name, age, position, salary):
        # 实例变量（每个实例独立）
        self.name = name
        self.age = age
        self.position = position
        self.salary = salary
        self.department = None  # 初始无部门
        Employee.employee_count += 1  # 类变量递增
    def join_department(self, department):
        """加入部门（建立组合关系）"""
        self.department = department
        department.add_employee(self)
    def get_info(self):
        info = f"姓名：{self.name}, 职位：{self.position}, 薪资：{self.salary}"
        if self.department:
            info += f", 部门：{self.department.name}"
        return info
    @classmethod
    def create_manager(cls, name, age, salary):
        """类方法：创建经理（固定的职位）"""
        return cls(name, age, "部门经理", salary)
    @staticmethod
    def validate_salary(salary):
        """静态方法：验证薪资合法性"""
        return salary > 0 and salary < 1000000
# 使用示例
# 创建部门
engineering = Department("研发部")
marketing = Department("市场部")
# 通过类方法创建经理
zhang = Employee.create_manager("张经理", 35, 30000)
li = Employee.create_manager("李经理", 32, 28000)
# 创建普通员工
wang = Employee("王工", 28, "高级工程师", 20000)
zhao = Employee("赵工", 25, "软件工程师", 15000)
chen = Employee("陈专员", 26, "市场专员", 12000)
# 建立组合关系
wang.join_department(engineering)
zhao.join_department(engineering)
chen.join_department(marketing)
zhang.join_department(engineering)  # 经理也是员工
# 显示信息
print(f"公司：{Employee.company}")   # 公司：XX科技有限公司
print(f"员工总数：{Employee.employee_count}")  # 员工总数：5
print(engineering)  # 部门：研发部，员工数：3
print(wang.get_info())
print(Employee.validate_salary(500000))  # False

OOP 特性展示：

组合：Employee 包含 Department 引用
类变量/类方法：employee_count、create_manager
静态方法：validate_salary
关联关系：双向关联（员工知道部门,部门知道员工）

图书馆借阅系统（综合案例）

import datetime
class Book:
    """图书类"""
    def __init__(self, isbn, title, author, total_copies):
        self.isbn = isbn
        self.title = title
        self.author = author
        self.total_copies = total_copies
        self.available_copies = total_copies  # 可借数量
    def is_available(self):
        return self.available_copies > 0
    def borrow(self):
        if self.is_available():
            self.available_copies -= 1
            return True
        return False
    def return_book(self):
        if self.available_copies < self.total_copies:
            self.available_copies += 1
            return True
        return False
    def __str__(self):
        return f"《{self.title}》 by {self.author} (剩余{self.available_copies}/{self.total_copies})"
class Member:
    """会员类"""
    def __init__(self, member_id, name):
        self.member_id = member_id
        self.name = name
        self.borrowed_books = []  # 借阅记录
    def borrow_book(self, book):
        if len(self.borrowed_books) >= 5:
            print(f"{self.name} 已达到最大借阅数量")
            return False
        if book.borrow():
            self.borrowed_books.append({
                'book': book,
                'borrow_date': datetime.date.today()
            })
            print(f"{self.name} 借阅《{book.title}》成功")
            return True
        else:
            print(f"《{book.title}》暂无库存")
            return False
    def return_book(self, book):
        for record in self.borrowed_books:
            if record['book'] is book:
                book.return_book()
                self.borrowed_books.remove(record)
                print(f"{self.name} 归还《{book.title}》成功")
                return True
        print(f"{self.name} 没有借阅《{book.title}》")
        return False
    def __str__(self):
        return f"会员：{self.name} (ID:{self.member_id}), 已借{len(self.borrowed_books)}本"
class Library:
    """图书馆类（管理所有书籍和会员）"""
    def __init__(self, name):
        self.name = name
        self.books = {}
        self.members = {}
    def add_book(self, book):
        self.books[book.isbn] = book
        print(f"添加图书：{book}")
    def register_member(self, member):
        self.members[member.member_id] = member
        print(f"注册会员：{member}")
    def borrow_book(self, member_id, isbn):
        member = self.members.get(member_id)
        book = self.books.get(isbn)
        if member and book:
            member.borrow_book(book)
        else:
            print("会员或图书不存在")
    def return_book(self, member_id, isbn):
        member = self.members.get(member_id)
        book = self.books.get(isbn)
        if member and book:
            member.return_book(book)
        else:
            print("会员或图书不存在")
    def display_status(self):
        print(f"\n=== {self.name} 当前状态 ===")
        print("图书库存：")
        for book in self.books.values():
            print(f"  {book}")
        print("会员信息：")
        for member in self.members.values():
            print(f"  {member}")
# 使用示例
library = Library("智慧图书馆")
# 添加图书
library.add_book(Book("978-7-111-11111-1", "Python编程", "张三", 3))
library.add_book(Book("978-7-111-22222-2", "数据结构", "李四", 2))
library.add_book(Book("978-7-111-33333-3", "算法导论", "王五", 1))
# 注册会员
library.register_member(Member("M001", "小明"))
library.register_member(Member("M002", "小红"))
# 借还书操作
library.borrow_book("M001", "978-7-111-11111-1")  # 小明借Python编程
library.borrow_book("M001", "978-7-111-22222-2")  # 小明借数据结构
library.borrow_book("M002", "978-7-111-11111-1")  # 小红借Python编程
library.display_status()
library.return_book("M001", "978-7-111-11111-1")  # 小明还Python编程
library.display_status()

OOP 特性展示：

类关系设计：Library 聚合 Book 和 Member
职责分离：每个类负责自己的业务逻辑
对象交互：Member 与 Book 协同完成借阅
封装：内部状态通过方法管理

OOP 核心概念总结表

概念	案例位置	说明
封装	银行账户 `__balance`	隐藏内部数据，通过方法访问
继承	SavingsAccount -> BankAccount	复用父类代码，扩展新功能
多态	Animal -> Dog/Cat/Duck	统一接口，不同实现
抽象	Animal 抽象基类	定义接口规范
组合	Employee + Department	“has-a”关系
类方法	Employee.create_manager	工厂方法模式
静态方法	Employee.validate_salary	工具函数，无关实例