面向对象与面向过程：编程范式的两大流派

# 定义函数：计算面积
def calculate_area(width, height):
    return width * height

# 定义函数：计算周长
def calculate_perimeter(width, height):
    return 2 * (width + height)

# 主程序
width = 10
height = 5
area = calculate_area(width, height)
perimeter = calculate_perimeter(width, height)
print(f"面积：{area}，周长：{perimeter}")

2. 面向对象（Object-Oriented Programming）

核心思想：将数据（属性）和操作数据的函数（方法）封装为对象，通过对象间的交互实现功能。
数据与行为绑定：对象内部包含数据和操作数据的逻辑，外部通过接口访问对象。

四大特性：

封装：隐藏内部实现细节，仅暴露必要接口。
继承：子类继承父类的属性和方法，实现代码复用。
多态：同一接口可由不同对象实现不同行为。
抽象：提取共性，定义抽象类或接口。

示例：计算矩形面积（面向对象）

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def calculate_area(self):
        return self.width * self.height
    
    def calculate_perimeter(self):
        return 2 * (self.width + self.height)

# 创建对象并调用方法
rect = Rectangle(10, 5)
print(f"面积：{rect.calculate_area()}，周长：{rect.calculate_perimeter()}")

二、优缺点对比

1. 面向过程的优缺点

优点：

简单直接：逻辑清晰，适合小型、简单任务。
执行效率高：无需创建对象，函数调用开销小。
易于调试：流程明确，问题定位简单。

缺点：

代码复用性差：函数与数据关联弱，难以复用。
可维护性低：代码量大时，函数间依赖复杂，修改易引发连锁反应。
扩展性差：需求变更时需修改多处代码。

2. 面向对象的优缺点

优点：

高复用性：通过继承和组合，可复用已有类。
高可维护性：封装降低模块间耦合，修改局部不影响整体。
高扩展性：通过多态和接口，可轻松添加新功能。
符合人类思维：用对象模拟现实世界，设计更直观。

缺点：

学习门槛高：需理解抽象概念（如继承、多态）。
代码复杂度高：小型项目可能过度设计，增加代码量。
性能开销：对象创建和方法调用比函数调用稍慢。

三、适用场景对比

1. 面向过程适合的场景

简单任务：如脚本工具、一次性数据处理。
性能敏感场景：如嵌入式系统、实时计算。
算法实现：专注逻辑，无需复杂数据结构。

2. 面向对象适合的场景

复杂系统：如 Web 框架、游戏引擎、企业级应用。
需要高度复用：如开发库或框架，避免重复造轮子。
需求易变：通过多态和接口设计，灵活应对变化。

四、实战对比：用两种范式实现图书馆系统

1. 面向过程实现

# 数据存储（全局变量）
books = []

# 添加书籍
def add_book(title, author):
    books.append({"title": title, "author": author, "borrowed": False})

# 借阅书籍
def borrow_book(title):
    for book in books:
        if book["title"] == title and not book["borrowed"]:
            book["borrowed"] = True
            return True
    return False

# 归还书籍
def return_book(title):
    for book in books:
        if book["title"] == title and book["borrowed"]:
            book["borrowed"] = False
            return True
    return False

2. 面向对象实现

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.borrowed = False
    
    def borrow(self):
        if not self.borrowed:
            self.borrowed = True
            return True
        return False
    
    def return_book(self):
        if self.borrowed:
            self.borrowed = False
            return True
        return False

class Library:
    def __init__(self):
        self.books = []
    
    def add_book(self, book):
        self.books.append(book)
    
    def find_book(self, title):
        return next((b for b in self.books if b.title == title), None)

五、混合范式：现代编程的主流选择

现代编程语言（如 Python、Java）支持两种范式，实际项目中常混合使用：

以面向对象为主：用类组织代码，实现高内聚、低耦合。
以面向过程为辅：在局部逻辑简单处使用函数，避免过度封装。

示例：Python 中混合范式

# 面向对象：定义数据模型
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def is_adult(self):
        return self.age >= 18

# 面向过程：定义工具函数
def format_user(user: User) -> str:
    return f"姓名：{user.name}，年龄：{user.age}，成年：{user.is_adult()}"

# 使用
user = User("Alice", 25)
print(format_user(user))  # 姓名：Alice，年龄：25，成年：True

总结

对比项	面向过程	面向对象
核心	函数（过程）	对象（数据 + 行为）
数据与逻辑	分离	绑定
复用方式	函数调用	继承、组合
适用场景	简单任务、性能敏感	复杂系统、需求易变
典型语言	C、Fortran	Java、Python、C++