在面向对象编程（OOP）与 UML 类图设计中，类与类之间存在多种静态结构关系，其中组合、聚合、继承是最核心的三类关系：继承描述 “类型从属” 的层级关系，聚合与组合描述 “整体 - 部分” 的组装关系，三者在语义、耦合度、生命周期管理和适用场景上有本质区别。
一、概念总览
从语义分类上，三者分属两个不同的关系体系：
- 继承（泛化）：属于类级别的类型关系，表达
is-a（是一种）的语义，核心作用是实现代码复用与多态。 - 聚合、组合：都属于对象级别的关联关系，表达
has-a（拥有）的整体 - 部分语义，核心作用是实现对象组装与功能协作；二者的唯一本质差异是部分与整体的生命周期绑定强度。
二、继承（Inheritance / Generalization）
1. 核心定义
继承是面向对象三大核心特性（封装、继承、多态）之一，描述父类（基类）与子类（派生类）之间的泛化 - 特化关系：子类自动拥有父类所有非私有属性与方法，同时可以扩展自身独有特性，还能通过重写父类方法实现多态。 它是一种编译期静态确定的白箱复用机制—— 父类的内部实现细节对子类可见。
2. 核心特征
- 强语义约束：必须严格符合 “子类是一种父类” 的逻辑，例如 “猫是一种动物”，违背该逻辑会导致设计灾难。
- 耦合度极高：父类的修改会直接传导到所有子类，存在 “脆弱的基类问题”。
- 静态性：继承关系在编译期确定，运行时无法动态改变。
- 支持多态：通过虚函数 / 方法重写，实现运行时动态绑定。
- 层级限制：多数语言仅支持单继承，多继承易引发菱形继承、命名冲突等问题。
3. UML 表示
用空心三角箭头 + 实线表示，箭头指向父类。
4. C++ 代码示例
cpp
运行
#include <iostream> using namespace std; // 父类：动物（泛化抽象） class Animal { protected: string name; public: Animal(string n) : name(n) {} virtual void speak() { // 虚函数，支持多态重写 cout << name << " 发出叫声" << endl; } virtual ~Animal() {} // 虚析构函数，避免子类内存泄漏 }; // 子类：猫（特化实现） class Cat : public Animal { public: Cat(string n) : Animal(n) {} void speak() override { // 重写父类方法 cout << name << " 喵喵叫" << endl; } void catchMouse() { // 子类独有扩展方法 cout << name << " 抓老鼠" << endl; } }; // 子类：狗（特化实现） class Dog : public Animal { public: Dog(string n) : Animal(n) {} void speak() override { cout << name << " 汪汪叫" << endl; } }; int main() { // 多态：父类指针指向子类对象 Animal* a1 = new Cat("橘猫"); Animal* a2 = new Dog("柴犬"); a1->speak(); // 输出：橘猫 喵喵叫 a2->speak(); // 输出：柴犬 汪汪叫 delete a1; delete a2; return 0; }三、聚合（Aggregation）
1. 核心定义
聚合是关联关系的弱形式，表达弱拥有的整体 - 部分语义：整体对象 “包含” 部分对象，但部分对象可以独立于整体存在，二者生命周期完全分离。 整体不负责部分的创建与销毁，一个部分对象可以同时被多个整体对象共享。
2. 核心特征
- 可分离性：部分可以脱离整体独立存在，整体销毁后部分仍有意义。
- 生命周期独立：部分对象由外部创建和管理，整体仅持有引用 / 指针。
- 可共享：同一部分实例可以归属多个整体。
- 耦合度低：整体仅通过公共接口访问部分，不感知内部实现。
典型场景：班级与学生、公司与员工、书架与书籍 —— 班级解散后学生依然存在，员工可以同时任职多家公司。
3. UML 表示
用空心菱形 + 实线表示，菱形指向整体对象。
4. C++ 代码示例
聚合关系中，整体类仅持有部分类的指针，部分对象由外部传入，整体析构时不释放部分对象。
cpp
运行
#include <iostream> #include <vector> using namespace std; // 部分类：学生 class Student { private: string id; string name; public: Student(string i, string n) : id(i), name(n) {} string getName() { return name; } }; // 整体类：班级 class Class { private: string className; vector<Student*> students; // 仅持有指针，不管理生命周期 public: Class(string name) : className(name) {} // 外部传入学生对象 void addStudent(Student* s) { students.push_back(s); } void showStudents() { cout << className << " 学生名单：" << endl; for (auto s : students) cout << "- " << s->getName() << endl; } // 析构不释放学生，班级解散不影响学生存在 ~Class() { cout << className << " 已解散" << endl; } }; int main() { // 外部独立创建学生 Student* s1 = new Student("001", "张三"); Student* s2 = new Student("002", "李四"); Class* c1 = new Class("计科1班"); c1->addStudent(s1); c1->addStudent(s2); c1->showStudents(); delete c1; // 班级销毁 cout << s1->getName() << " 依然存在" << endl; // 学生不受影响 delete s1; delete s2; return 0; }四、组合（Composition）
1. 核心定义
组合是关联关系的强形式，表达强拥有的整体 - 部分语义：部分对象是整体不可分割的固有组成，二者生命周期严格绑定 —— 整体创建时创建部分，整体销毁时部分也随之销毁。 整体完全负责部分的生命周期管理，部分不能脱离整体独立存在。
2. 核心特征
- 不可分割：部分是整体的固有组成，脱离整体后失去存在意义。
- 生命周期绑定：部分的创建、销毁完全由整体控制，同生共死。
- 不可共享：一个部分实例只能归属一个整体。
- 耦合度中等：整体管理部分生命周期，但仍通过接口交互。
典型场景：人与心脏、订单与订单项、文件与文件内容 —— 人死亡后心脏无法独立存活，订单删除后订单项也无存在价值。
3. UML 表示
用实心菱形 + 实线表示，菱形指向整体对象。
4. C++ 代码示例
组合关系中，整体类内部直接创建部分实例，析构时负责释放所有部分对象。
cpp
运行
#include <iostream> #include <vector> using namespace std; // 部分类：订单项 class OrderItem { private: string productName; int quantity; double price; public: OrderItem(string name, int qty, double p) : productName(name), quantity(qty), price(p) {} double getTotal() { return quantity * price; } void showInfo() { cout << productName << " × " << quantity << "，单价：" << price << "元" << endl; } }; // 整体类：订单 class Order { private: string orderId; vector<OrderItem*> items; // 内部管理所有订单项生命周期 public: Order(string id) : orderId(id) {} // 内部创建订单项 void addItem(string name, int qty, double price) { items.push_back(new OrderItem(name, qty, price)); } double getTotalAmount() { double total = 0; for (auto item : items) total += item->getTotal(); return total; } void showOrder() { cout << "订单号：" << orderId << endl; cout << "商品明细：" << endl; for (auto item : items) item->showInfo(); cout << "总金额：" << getTotalAmount() << "元" << endl; } // 析构时同步销毁所有订单项 ~Order() { for (auto item : items) delete item; items.clear(); cout << "订单 " << orderId << " 删除，订单项同步销毁" << endl; } }; int main() { Order* order = new Order("ORD20260813"); order->addItem("机械键盘", 1, 399.0); order->addItem("鼠标垫", 2, 29.9); order->showOrder(); delete order; // 订单销毁时，订单项一并释放 return 0; }五、三者核心对比与选择原则
1. 多维度对比表
表格
| 对比维度 | 继承（泛化） | 聚合 | 组合 |
|---|---|---|---|
| 核心语义 | is-a（是一种） | has-a（拥有） | contains-a（包含） |
| 关系层级 | 类级别 | 对象级别 | 对象级别 |
| 生命周期 | 类定义依赖，对象实例独立 | 整体与部分完全独立 | 部分与整体严格绑定 |
| 复用方式 | 白箱复用，破坏封装 | 黑箱复用，接口交互 | 黑箱复用，接口交互 |
| 耦合度 | 最高 | 最低 | 中等偏高 |
| 灵活性 | 差，编译期固定 | 最高，运行时可动态替换 | 中等，整体内固定 |
| 共享性 | 不涉及 | 部分可被多整体共享 | 部分不可共享 |
| UML 符号 | 空心三角 + 实线 | 空心菱形 + 实线 | 实心菱形 + 实线 |
2. 聚合 vs 组合：一句话区分
判断标准只有一个：删除整体对象时，部分对象还有没有独立存在的意义？
- 有意义 → 聚合（比如公司没了，员工还能找新工作）
- 没意义 → 组合（比如人没了，心脏无法单独存活）
注意：二者没有绝对对错，完全由业务语义决定。同一种关系在不同场景下可能归类不同：汽车生产场景中轮胎是汽车的固有组成，属于组合；汽修店场景中轮胎可单独拆卸售卖，属于聚合。
3. 继承 vs 组合：合成复用原则
面向对象设计有一条核心原则：优先使用对象组合，而非类继承来实现代码复用。
表格
| 继承的固有缺陷 | 组合 / 聚合的优势 |
|---|---|
| 编译期静态绑定，运行时无法修改 | 运行时动态替换部分，灵活性极强 |
| 父类细节暴露给子类，破坏封装 | 对象间仅通过接口交互，封装性好 |
| 父类变更会牵连所有子类，维护成本高 | 部分类变更通常不影响整体类 |
| 继承层级过深会导致结构臃肿、难以理解 | 结构扁平，职责清晰 |
| 多数语言仅支持单继承，复用维度单一 | 可组合多个不同类型的对象，能力扩展自由 |
何时该用继承？
- 明确存在
is-a语义，且子类完全符合里氏替换原则（所有父类方法对子类都适用）； - 需要利用多态统一处理不同子类对象；
- 子类需要重写父类的核心行为，而非单纯复用代码。
何时该用组合 / 聚合？
- 仅为了复用代码，不存在
is-a语义； - 需要在运行时动态切换功能实现；
- 一个类需要复用多个类的能力；
- 希望降低系统耦合度，提升可维护性。
六、常见设计陷阱
滥用继承实现代码复用强行让不具备
is-a关系的类继承（例如 “正方形继承长方形”），看似节省代码，实则违反里氏替换原则，后期维护成本极高。混淆聚合与组合的生命周期UML 图中随意使用空心 / 实心菱形，本质是未理清业务中对象的归属关系。设计时必须先明确 “谁管理谁的生命周期”。
继承层级过深继承层级超过 3 层会严重降低可读性，出现 “改一行基类，全链子类出问题” 的灾难。层级过深时，应当用组合拆分扁平化。
七、总结
- 继承解决 “类型抽象与多态” 问题，核心是
is-a，耦合最高、灵活性最差，是面向对象的基础但非首选复用方式。 - 聚合解决 “对象组装与共享” 问题，核心是弱
has-a，耦合最低、灵活性最高，适合可分离、可共享的整体 - 部分场景。 - 组合解决 “对象封装与统一生命周期” 问题，核心是强
contains-a，结构最稳固，适合不可分割的整体 - 部分场景。
优秀的面向对象设计，应当遵循 “组合优先、继承为辅” 的思路，根据业务语义精准选择关系类型，构建低耦合、高内聚的系统。
