Python 类的组合与继承：代码世界的“血缘”与“联姻

# 父类（基类）
class Phone:
    def __init__(self, brand):
        self.brand = brand
    
    def call(self):
        print(f"{self.brand} 正在打电话...")
    
    def send_sms(self):
        print(f"{self.brand} 正在发短信...")

# 子类（派生类）—— 继承 Phone
class SmartPhone(Phone):   # 括号里写父类名
    def take_photo(self):
        print(f"{self.brand} 正在拍照，咔嚓！")
    
    def play_game(self):
        print(f"{self.brand} 正在打游戏...")

# 使用
p1 = SmartPhone("华为")
p1.call()          # ✅ 来自父类：华为 正在打电话...
p1.take_photo()    # ✅ 自己的新功能：华为 正在拍照，咔嚓！

📌 子类 SmartPhone 没有写 __init__，也没写 call()，但它自动拥有了父类的所有属性和方法。

1.3 父类和子类的关系

python

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(f"{self.name} 正在吃东西")

class Dog(Animal):
    def bark(self):
        print(f"{self.name} 汪汪叫！")

class Cat(Animal):
    def meow(self):
        print(f"{self.name} 喵喵叫！")

# 创建实例
dog = Dog("旺财")
cat = Cat("咪咪")

dog.eat()    # 旺财 正在吃东西（继承自 Animal）
dog.bark()   # 旺财 汪汪叫！（自己的）
cat.eat()    # 咪咪 正在吃东西（继承自 Animal）
cat.meow()   # 咪咪 喵喵叫！（自己的）

1.4 方法重写 —— 子类不满意，可以“自己来”

子类对父类的方法不满意？直接重新写一个同名的，就覆盖掉了：

python

class Animal:
    def speak(self):
        print("动物发出了声音")

class Dog(Animal):
    def speak(self):   # 重写父类的 speak
        print("汪汪！")

class Cat(Animal):
    def speak(self):   # 重写父类的 speak
        print("喵喵～")

dog = Dog()
cat = Cat()
dog.speak()   # 汪汪！
cat.speak()   # 喵喵～

1.5 `super()` —— 既要子类自己的，也要父类的

有时候你想在子类里给父类的方法“加点料”，而不是完全覆盖：

python

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self, name, age, breed):
        # 先调用父类的 __init__ 处理 name 和 age
        super().__init__(name, age)
        # 再处理自己的新属性
        self.breed = breed

dog = Dog("旺财", 3, "金毛")
print(dog.name)    # 旺财（父类处理的）
print(dog.age)     # 3（父类处理的）
print(dog.breed)   # 金毛（自己的）

📌 super() 就是“叫一声老爸”——把父类的方法拉过来先用，不够的再自己加。

1.6 继承核心总结

概念	说明
父类	被继承的类，也叫基类
子类	继承父类的类，也叫派生类
继承语法	`class 子类(父类):`
方法重写	子类重新定义父类的方法
super()	调用父类的方法

第二部分：组合 —— 代码世界的“合伙关系”

2.1 组合是啥？

组合就是一个类把另一个类的实例当作自己的属性。

继承是“我是谁”（Dog 是 Animal），组合是“我有谁”（Computer 有 CPU、有 Disk）。

打个比方：你组装一台电脑。

CPU、内存、硬盘……每个部件都是一个独立的类

电脑类不继承它们，而是把它们装进自己内部

电脑能干什么是靠这些部件协作完成的

继承是“血缘”，组合是“联姻”。

2.2 组合的基本写法

python

class CPU:
    def run(self):
        print("CPU 正在处理数据...")

class Memory:
    def load(self):
        print("内存正在加载数据...")

class Disk:
    def read(self):
        print("硬盘正在读取数据...")

class Computer:
    def __init__(self):
        # 组合：把其他类的实例变成自己的部件
        self.cpu = CPU()
        self.memory = Memory()
        self.disk = Disk()
    
    def start(self):
        self.disk.read()
        self.memory.load()
        self.cpu.run()
        print("电脑启动完成！")

# 使用
my_pc = Computer()
my_pc.start()

输出：

text

硬盘正在读取数据...
内存正在加载数据...
CPU 正在处理数据...
电脑启动完成！

2.3 继承 vs 组合 —— 什么时候用谁？

继承：适用于 “是什么” 的关系。

狗是动物 → class Dog(Animal)

智能手机是手机 → class SmartPhone(Phone)

组合：适用于 “有什么” 的关系。

电脑有 CPU → Computer 里放一个 CPU 实例

汽车有引擎 → Car 里放一个 Engine 实例

学生有书包 → Student 里放一个 Bag 实例

python

# 继承：Dog IS-A Animal（狗是动物）
class Dog(Animal):
    pass

# 组合：Dog HAS-A Tail（狗有尾巴）
class Dog:
    def __init__(self):
        self.tail = Tail()

2.4 组合更灵活，继承更省事

维度	继承	组合
关系	父子关系（is-a）	拥有关系（has-a）
代码复用	自动获得父类所有属性和方法	需要手动调用
耦合度	高（子类依赖父类）	低（部件可独立更换）
灵活性	差（绑死了继承链）	好（部件随意换）
适用场景	天然有层次关系	模块化组装

总结

🎯 继承 vs 组合一张图总结

text

        继承                           组合
                      
        Animal                        Engine 
        吃 睡                          启动   
                     
          继承                         拥有
           ↓                             ↓
                       
        Dog                              Car         
        汪汪                            行驶   
                   

     Dog IS-A Animal              Car HAS-A Engine
     （狗是动物）                  （汽车有引擎）

今天你学到了两样新东西：

继承 —— 解决“我是谁”。儿子继承老爸，少写重复代码，还能自己添新功能。适合有天然层次关系的场景。

组合 —— 解决“我有谁”。就像拼乐高，每个部件独立，想怎么拼就怎么拼。适合模块化组装的场景。

这两种关系不是二选一，而是配合着用：

你的 Dog 类继承了 Animal（继承）

你的 Dog 类里有一个 Tail 实例（组合）

用了继承，代码有了“家族树”；用了组合，代码有了“朋友圈”。两个加在一起，你的面向对象才算真正成型。