面向过程 vs 面向对象对比与分析：通过简单实现“人狗对战”

一、面向过程实现

# 攻击值定义
attack_vals = {
    "京巴": 30,
    "藏獒": 80
}

# 生成狗的信息
def dog(name, dtype):
    data = {
        "name": name,
        "dtype": dtype,
        "life_val": 100,
        "attack_val": attack_vals[dtype]
    }
    return data

# 生成人的信息
def person(name, age):
    data = {"name": name, "age": age}
    if age > 18:
        data["attack_val"] = 50
    else:
        data["attack_val"] = 30
    data["life_val"] = 100
    return data

# 狗咬人逻辑
def dog_bite(dog_obj, person_obj):
    person_obj["life_val"] -= dog_obj["attack_val"]
    print(f"{dog_obj['name']}咬了{person_obj['name']}一口，{person_obj['name']}掉血{dog_obj['attack_val']}，剩余血量{person_obj['life_val']}")

# 人打狗逻辑
def beat(person_obj, dog_obj):
    dog_obj["life_val"] -= person_obj["attack_val"]
    print(f"{person_obj['name']}打了{dog_obj['name']}一拳，{dog_obj['name']}掉血{person_obj['attack_val']}，剩余血量{dog_obj['life_val']}")

# 实例化与对战
d1 = dog("京巴", "京巴")
d2 = dog("藏獒", "藏獒")
p1 = person("Alex", 22)

dog_bite(d1, p1)
beat(p1, d1)

二、面向对象实现

class Role:
    def __init__(self, name, life_val=100):
        self.name = name
        self.life_val = life_val

    def attack(self, enemy):
        enemy.life_val -= self.attack_val
        print(f"{self.name}攻击了{enemy.name}，造成{self.attack_val}点伤害，{enemy.name}剩余血量{enemy.life_val}")

    def is_alive(self):
        return self.life_val > 0

class Dog(Role):
    def __init__(self, name, dtype, life_val=100):
        super().__init__(name, life_val)
        self.attack_vals = {
            "京巴": 30,
            "藏獒": 80
        }
        self.attack_val = self.attack_vals[dtype]
        self.dtype = dtype

class Person(Role):
    def __init__(self, name, age, life_val=100):
        super().__init__(name, life_val)
        self.attack_val = 50 if age > 18 else 30
        self.age = age

# 实例化与对战
dog1 = Dog("京巴", "京巴")
dog2 = Dog("藏獒", "藏獒")
person1 = Person("Alex", 22)

dog1.attack(person1)
person1.attack(dog1)

三、两种实现的优缺点对比

维度	面向过程实现	面向对象实现
代码组织	函数分散，逻辑关联弱，大型项目易混乱	类封装属性和行为，逻辑内聚，结构清晰
扩展性	新增角色（如猫）需大量修改函数	新增角色只需继承Role并重写方法，扩展性强
复用性	函数间依赖参数传递，复用需重复写逻辑	类的继承和方法重写支持高度复用
可读性	依赖注释理解函数用途，逻辑链长	类和方法名直观，通过对象.方法调用，可读性高
维护性	修改逻辑易影响全局，Bug排查困难	封装使修改局部化，维护成本低
学习成本	入门简单，适合小型脚本	需理解类、对象、继承等概念，入门稍难

四、总结

• 面向过程适合小型、逻辑简单的脚本（如临时数据处理、简单工具），优点是入门快、代码直接；缺点是扩展性和维护性差。
• 面向对象适合中大型、需长期维护或扩展的项目（如游戏、系统开发），优点是结构清晰、复用性强；缺点是入门有一定学习成本。

在“人狗对战”场景中，面向对象通过类封装角色的属性和行为，让代码更易扩展（如新增“猫”角色只需继承Role），也更符合现实中“角色有自己行为”的逻辑；而面向过程则更偏向“步骤化执行”，适合快速验证简单逻辑。