🐍 Python面向对象：从“类”到“超”能力

想要让代码像乐高一样灵活组装？面向对象编程（OOP）就是你的魔法工具箱！

一、类与对象：万物皆可“类”化

什么是类？

想象一下月饼模具——模具就是“类”，用它压出来的月饼就是“对象”。同一个模具可以做出无数个月饼，每个都是独立的个体！

class 月饼模具:
    # 类属性：所有月饼共享的特征
    默认口味 = "莲蓉"
    默认重量 = 100  # 克
    
    def 查看月饼(self):
        print(f"我是一个{self.口味}月饼，重{self.重量}克")
        print(f"self其实就是我自己：{self}")

# 使用模具制作月饼
月饼1 = 月饼模具()
月饼1.口味 = "豆沙"  # 实例属性
print(月饼1.默认口味)  # 输出：莲蓉

月饼2 = 月饼模具()
月饼2.重量 = 150
月饼2.添加物 = "蛋黄"  # 动态添加新属性！

🔑 关键点速记：

  • 类 = 蓝图/模板
  • 对象 = 根据蓝图创建的具体实例
  • self = 实例的“自拍杆”，永远指向对象自己
  • 类属性 = 所有实例共享
  • 实例属性 = 每个实例独有

二、继承：龙生龙，凤生凤

单继承：子承父业

class 动物:
    def __init__(self, 名字):
        self.名字 = 名字
    
    def 叫(self):
        print("某种动物的叫声...")

class 狗(动物):  # 继承自动物类
    def 叫(self):  # 重写父类方法
        print(f"{self.名字}：汪汪汪！")

class 猫(动物):
    def 叫(self):
        print(f"{self.名字}：喵喵喵！")

旺财 = 狗("旺财")
咪咪 = 猫("咪咪")

旺财.叫()  # 输出：旺财：汪汪汪！
咪咪.叫()  # 输出：咪咪：喵喵喵！

print(isinstance(旺财, 狗))  # True
print(isinstance(旺财, 动物))  # True，狗也是动物
print(issubclass(猫, 动物))  # True，猫是动物的子类

多重继承：混血天才

class 游泳健将:
    def 游泳(self):
        return "我会游泳！"

class 飞行高手:
    def 飞行(self):
        return "我会飞行！"

class 鸭嘴兽(游泳健将, 飞行高手):
    def 自我介绍(self):
        print(f"我是鸭嘴兽，{self.游泳()} {self.飞行()}")

鸭鸭 = 鸭嘴兽()
鸭鸭.自我介绍()  # 我是鸭嘴兽，我会游泳！ 我会飞行！

# 方法解析顺序（MRO）
print(鸭嘴兽.__mro__)
# (<class '__main__.鸭嘴兽'>, <class '__main__.游泳健将'>, 
#  <class '__main__.飞行高手'>, <class 'object'>)

组合：团队合作

class 引擎:
    def 启动(self):
        print("引擎轰鸣...")

class 车轮:
    def 旋转(self):
        print("车轮滚滚...")

class 汽车:
    def __init__(self):
        self.引擎 = 引擎()  # 拥有一个引擎对象
        self.车轮们 = [车轮() for _ in range(4)]  # 拥有四个车轮
    
    def 驾驶(self):
        self.引擎.启动()
        for 车轮 in self.车轮们:
            车轮.旋转()
        print("汽车出发！")

我的车 = 汽车()
我的车.驾驶()

三、绑定：谁是谁的谁

实例绑定 vs 类绑定

class 手机:
    品牌 = "水果牌"  # 类属性
    
    def 打电话(self, 号码):
        print(f"正在拨打：{号码}")

# 类调用方法（需要手动传self）
手机.打电话("iphone", "110")  # 等价于 iphone.打电话("110")

iphone = 手机()
huawei = 手机()

# 修改实例属性不影响类属性
huawei.品牌 = "华子牌"
print(huawei.品牌)  # 华子牌
print(iphone.品牌)  # 水果牌
print(手机.品牌)    # 水果牌

# 查看所有属性
print(huawei.__dict__)  # {'品牌': '华子牌'}
print(手机.__dict__)    # 包含所有类属性和方法

四、构造函数：个性化定制

class 学生:
    # __init__ 就是构造函数，创建对象时自动调用
    def __init__(self, 姓名, 年龄, 爱好="打游戏"):
        self.姓名 = 姓名
        self.年龄 = 年龄
        self.爱好 = 爱好
        print(f"{姓名}同学入学啦！")
    
    def 自我介绍(self):
        print(f"我叫{self.姓名}，今年{self.年龄}岁，喜欢{self.爱好}")

小明 = 学生("小明", 18, "打篮球")
小红 = 学生("小红", 17)  # 使用默认爱好

小明.自我介绍()  # 我叫小明，今年18岁，喜欢打篮球
小红.自我介绍()  # 我叫小红，今年17岁，喜欢打游戏

五、重写与扩展：青出于蓝

class 员工:
    def __init__(self, 姓名, 工资):
        self.姓名 = 姓名
        self.工资 = 工资
    
    def 工作(self):
        print(f"{self.姓名}正在认真工作...")
    
    def 发工资(self):
        print(f"给{self.姓名}发了{self.工资}元工资")

class 经理(员工):
    def __init__(self, 姓名, 工资, 部门):
        # 方法1：直接调用父类方法
        员工.__init__(self, 姓名, 工资)
        
        # 方法2：使用super()（推荐！）
        # super().__init__(姓名, 工资)
        
        self.部门 = 部门
    
    def 工作(self):  # 重写父类方法
        super().工作()  # 先做员工的工作
        print(f"{self.姓名}正在管理{self.部门}部门")  # 再加上经理的工作
    
    def 开会(self):  # 扩展新方法
        print("经理正在开会...")

张经理 = 经理("张三", 20000, "技术部")
张经理.工作()
# 输出：
# 张三正在认真工作...
# 张三正在管理技术部部门

六、钻石继承与super()魔法

⚠️ 危险的菱形继承

class A:
    def 方法(self):
        print("A")

class B(A):
    def 方法(self):
        print("B")
        super().方法()

class C(A):
    def 方法(self):
        print("C")
        super().方法()

class D(B, C):  # 菱形继承
    def 方法(self):
        print("D")
        super().方法()

d = D()
d.方法()
# 输出顺序是什么？
# D -> B -> C -> A
# 这就是Python的MRO（方法解析顺序）

print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, 
#  <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

为什么要用super()？

# 传统方法的问题
class 爸爸:
    def __init__(self):
        print("爸爸初始化")
        self.属性 = "爸爸的"

class 妈妈:
    def __init__(self):
        print("妈妈初始化")
        self.属性 = "妈妈的"

class 孩子(爸爸, 妈妈):
    def __init__(self):
        爸爸.__init__(self)  # 问题：妈妈.__init__被忽略了！
        妈妈.__init__(self)  # 而且属性被覆盖了

# 使用super()的优雅解决方案
class 新孩子(爸爸, 妈妈):
    def __init__(self):
        super().__init__()  # 按MRO顺序调用所有父类的__init__
        print("孩子初始化")

宝宝 = 新孩子()
# 输出顺序遵循MRO：
# 爸爸初始化 -> 妈妈初始化 -> 孩子初始化

七、终极小抄：OOP核心概念表

概念 比喻 代码示例 关键点
类 月饼模具 class 类名: 对象的蓝图
对象 具体月饼 obj = 类名() 类的实例
继承 龙生龙 class 子类(父类): 代码复用
多态 同名不同功 同名方法不同实现 接口统一
封装 手机内部 私有属性_name 隐藏细节
组合 汽车+引擎 self.引擎 = 引擎() has-a关系
super() 接力棒 super().方法() 解决菱形继承

🎯 总结一下

面向对象编程就像在代码世界里创造生命：

  1. 类是你的造物蓝图
  2. 对象是活生生的存在
  3. 继承让优秀基因传递
  4. 多态让世界丰富多彩
  5. 封装保护对象的小秘密
  6. 组合让复杂事物成为可能

记住这个口诀：

类似蓝图造对象，继承复用不重写。
组合聚合要分清，super解构菱形结。
多态接口统一用，封装隐藏内部节。

现在，去创建你的第一个Python对象世界吧！记得，好的OOP设计就像乐高积木——每个部件独立，组合起来却能创造无限可能！ 🚀

# 你的第一个OOP程序
if __name__ == "__main__":
    print("面向对象，面向未来！")
    print("快去创建属于你的类吧！")

进阶预告：下一期我们将深入探讨魔法方法、装饰器、元类等高级OOP特性，让你的Python对象拥有真正的“超能力”！