面向对象设计原则

类和类之间的关系

类和类之间的关系

1、继承()

基类会成为派生类的一部分。在语义层面：A is B。在类图的画法上：从派生类指向基类的空心三角箭头。

继承：先有基类，然后派生出新的类，也就是派生类。

泛化（一般化）：先有派生类，将相同的属性抽出来，然后形成基类。

2、关联

2.1、双向的关联关系

双向的关联关系，彼此知道对方的存在，但是彼此不负责对方的生命周期。在语义层面：A has B。在代码层面上：使用的是指针或者引用。在类图的画法上：使用的是实心直线。

2.2、单向的关联关系

单向的关联关系，A知道对方的存在，但是B不知道A的存在。A不负责B的生命周期。在语义层面：A has B。在代码层面上：使用的是指针或者引用。在类图的画法上：从A指向B的实线箭头。

3、聚合

是一种稍强的关联关系，表现为整体与局部的关系，但是整体并不负责局部的销毁。在语义层面上：A has B。在代码层面上：使用的是指针或者引用。在类图的画法上:从局部指向整体的空心菱形箭头。

4、组合

是一种更强的关联关系，表现为整体与局部的关系，并且整体会负责局部的销毁。在语义层面上：A has B。在代码层面上：使用的是子对象。在类图的画法上:从局部指向整体的实心菱形箭头。

5、依赖

是两个类之间的一种不确定的关系，语义上是一种：A use B。这种关系是偶然的，临时的，并非固定的。在代码上表现为三种形式：

• B作为A的成员函数参数；

• B作为A的成员函数的局部变量或者B作为A的成员函数的返回值；

• A的成员函数调用B的静态方法。

类图的画法上：使用虚线的箭头从A指向B

6、总结

• 继承是垂直关系，其它的四种是水平关系；

• 从语义划分：继承 is；依赖：use；关联、聚合、组合：has；

• 从耦合强弱：依赖 < 关联 < 聚合 < 组合 < 继承；

• 从代码层面：依赖：主要体现在成员函数上； 关联、聚合、组合：主要体现在数据成员；继承：既有数据成员，也有成员函数；

面向对象的设计原则

三、设计模式

1、概念

设计模式是面向对象编程（OOP）中解决通用问题的成熟方案，核心目标是提升代码的复用性、可维护性、可扩展性，避免重复造轮子。它不是语法规则，而是基于大量实践总结的 “设计思想模板”，通常分为创建型、结构型、行为型三大类，每类对应不同场景的问题（如 “如何创建对象”“如何组织类结构”“如何交互通信”）。

设计模式的分类与核心目标

高频常用设计模式详解（C++ 实现）

一、创建型模式：解决 “对象如何创建” 的问题

 单例模式（Singleton）：创建型

1. 简单工厂模式（静态工厂方法）

核心定义

提供一个静态工厂类，通过传入参数判断创建哪种具体产品，实现 “对象创建与使用分离”。
⚠️ 本质是 “工厂集中判断”，非 23 种 GOF 模式，但是工厂模式的基础。

类图关系（文字描述）

核心代码

#include <iostream>
#include <memory>
using namespace std;

// 1. 抽象产品：定义产品统一接口
class Product {
public:
    virtual void show() = 0; // 纯虚函数，强制子类实现
    virtual ~Product() {}
};

// 2. 具体产品：实现抽象接口
class ProductA : public Product {
public:
    void show() override { cout << "ProductA::show()" << endl; }
};
class ProductB : public Product {
public:
    void show() override { cout << "ProductB::show()" << endl; }
};

// 3. 静态工厂：集中创建产品（核心）
class ProductFactory {
public:
    // 静态方法：根据类型创建产品，返回智能指针避免内存泄漏
    static unique_ptr<Product> createProduct(int type) {
        switch (type) {
            case 1: return make_unique<ProductA>();
            case 2: return make_unique<ProductB>();
            default: return nullptr;
        }
    }
};

// 使用示例
void test() {
    // 客户端只需传参数，无需关心创建细节
    auto pa = ProductFactory::createProduct(1);
    auto pb = ProductFactory::createProduct(2);
    if (pa) pa->show();
    if (pb) pb->show();
}

优缺点

使用场景

• 需创建的产品类型少（避免 switch 臃肿）；
• 客户端仅知产品参数，不关心创建细节（如工具类、简单组件）。

2. 工厂方法模式

核心定义

对简单工厂的工厂类抽象化：核心工厂变为抽象类，每个具体产品对应一个具体工厂，由子类决定创建哪种产品（“延迟到子类创建”）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <memory>
using namespace std;

// 1. 抽象产品
class Product {
public:
    virtual void show() = 0;
    virtual ~Product() {}
};
class ProductA : public Product {
public:
    void show() override { cout << "ProductA::show()" << endl; }
};
class ProductB : public Product {
public:
    void show() override { cout << "ProductB::show()" << endl; }
};

// 2. 抽象工厂（核心：定义工厂接口）
class Factory {
public:
    virtual unique_ptr<Product> createProduct() = 0; // 纯虚方法
    virtual ~Factory() {}
};

// 3. 具体工厂：一个产品对应一个工厂
class FactoryA : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ProductA>();
    }
};
class FactoryB : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ProductB>();
    }
};

// 使用示例
void test() {
    // 客户端需指定工厂类型，工厂创建对应产品
    unique_ptr<Factory> fa = make_unique<FactoryA>();
    unique_ptr<Product> pa = fa->createProduct();
    pa->show();

    unique_ptr<Factory> fb = make_unique<FactoryB>();
    unique_ptr<Product> pb = fb->createProduct();
    pb->show();
}

优缺点

使用场景

• 产品类型多变，需频繁新增产品（如插件、扩展组件）；
• 客户端知工厂名，不知产品创建细节（如框架中的插件工厂）。

3. 抽象工厂模式

核心定义

解决 “产品族” 创建问题：抽象工厂定义多个产品的创建接口，具体工厂对应一个产品族（同一品牌 / 系列的多类产品），实现 “一族产品统一创建”。

关键概念

• 产品等级结构：同一类产品的继承树（如 “电视机”→“海尔电视”“TCL 电视”）；
• 产品族：同一工厂生产的多等级产品（如 “海尔工厂”→“海尔电视”“海尔冰箱”）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <memory>
using namespace std;

// 1. 抽象产品族（多等级产品）
class AbstractProductA { // 产品A等级（如“电视”）
public:
    virtual void show() = 0;
    virtual ~AbstractProductA() {}
};
class AbstractProductB { // 产品B等级（如“冰箱”）
public:
    virtual void show() = 0;
    virtual ~AbstractProductB() {}
};

// 2. 具体产品（分产品族）
class ProductA1 : public AbstractProductA { // 族1的A产品（海尔电视）
public:
    void show() override { cout << "ProductA1::show()" << endl; }
};
class ProductB1 : public AbstractProductB { // 族1的B产品（海尔冰箱）
public:
    void show() override { cout << "ProductB1::show()" << endl; }
};
class ProductA2 : public AbstractProductA { // 族2的A产品（TCL电视）
public:
    void show() override { cout << "ProductA2::show()" << endl; }
};
class ProductB2 : public AbstractProductB { // 族2的B产品（TCL冰箱）
public:
    void show() override { cout << "ProductB2::show()" << endl; }
};

// 3. 抽象工厂（定义产品族的创建接口）
class AbstractFactory {
public:
    virtual unique_ptr<AbstractProductA> createProductA() = 0;
    virtual unique_ptr<AbstractProductB> createProductB() = 0;
    virtual ~AbstractFactory() {}
};

// 4. 具体工厂（对应产品族）
class Factory1 : public AbstractFactory { // 族1工厂（海尔工厂）
public:
    unique_ptr<AbstractProductA> createProductA() override {
        return make_unique<ProductA1>();
    }
    unique_ptr<AbstractProductB> createProductB() override {
        return make_unique<ProductB1>();
    }
};
class Factory2 : public AbstractFactory { // 族2工厂（TCL工厂）
public:
    unique_ptr<AbstractProductA> createProductA() override {
        return make_unique<ProductA2>();
    }
    unique_ptr<AbstractProductB> createProductB() override {
        return make_unique<ProductB2>();
    }
};

// 使用示例
void test() {
    // 创族1产品（海尔电视+冰箱）
    unique_ptr<AbstractFactory> f1 = make_unique<Factory1>();
    auto pa1 = f1->createProductA();
    auto pb1 = f1->createProductB();
    pa1->show();
    pb1->show();

    // 创族2产品（TCL电视+冰箱）
    unique_ptr<AbstractFactory> f2 = make_unique<Factory2>();
    auto pa2 = f2->createProductA();
    auto pb2 = f2->createProductB();
    pa2->show();
    pb2->show();
}

优缺点

使用场景

• 系统需使用多个关联产品（产品族），且需保证族内一致性（如 UI 组件库、品牌套件）；
• 产品族稳定，极少新增产品等级（如家电、汽车系列）。

二、结构型模式：解决 “对象如何组合” 的问题

核心目标：通过组合优化对象结构，实现功能扩展或解耦。

4. 装饰器模式

核心定义

动态给对象添加新功能：不修改原对象代码，通过 “装饰器类包装原对象”，递归叠加多个装饰器实现功能组合（“套娃式扩展”）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <memory>
using namespace std;

// 1. 抽象组件：定义核心功能接口
class Component {
public:
    virtual void operation() = 0;
    virtual ~Component() {}
};

// 2. 具体组件：原始对象（被装饰者）
class ConcreteComponent : public Component {
public:
    void operation() override {
        cout << "原始组件：基础功能" << endl;
    }
};

// 3. 抽象装饰器：包装组件，保持接口一致
class Decorator : public Component {
public:
    Decorator(Component* comp) : _comp(comp) {} // 注入被装饰组件
    void operation() override {
        if (_comp) _comp->operation(); // 调用被装饰者的基础功能
    }
    virtual ~Decorator() {}
protected:
    Component* _comp; // 指向被装饰的组件（多态）
};

// 4. 具体装饰器：扩展功能
class DecoratorA : public Decorator {
public:
    DecoratorA(Component* comp) : Decorator(comp) {}
    void operation() override {
        Decorator::operation(); // 先执行基础功能
        addFuncA(); // 新增功能A
    }
private:
    void addFuncA() { cout << "装饰器A：新增功能A" << endl; }
};
class DecoratorB : public Decorator {
public:
    DecoratorB(Component* comp) : Decorator(comp) {}
    void operation() override {
        Decorator::operation(); // 先执行基础功能（含A的扩展）
        addFuncB(); // 新增功能B
    }
private:
    void addFuncB() { cout << "装饰器B：新增功能B" << endl; }
};

// 使用示例
void test() {
    // 1. 原始组件
    unique_ptr<Component> comp = make_unique<ConcreteComponent>();
    comp->operation(); // 仅基础功能

    // 2. 装饰器A包装（基础+A）
    unique_ptr<Decorator> decA = make_unique<DecoratorA>(comp.get());
    decA->operation();

    // 3. 装饰器B包装A（基础+A+B）
    unique_ptr<Decorator> decB = make_unique<DecoratorB>(decA.get());
    decB->operation();
}

优缺点

使用场景

• 需动态给对象加 / 删功能（如 UI 组件加边框、阴影、滚动条）；
• 避免用继承产生大量子类（如 1 个组件 + 3 功能 = 3 装饰器，而非 8 个子类）；
• 功能可组合（如日志系统加 “时间戳 + 格式化 + 加密”）。

三、行为型模式：解决 “对象如何交互” 的问题

核心目标：优化对象间的通信、职责分配与行为复用。

5. 观察者模式

核心定义

定义 “一对多” 依赖：当被观察者（主题） 状态变化时，自动通知所有观察者，并触发其更新（“发布 - 订阅” 模式）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <list>
#include <memory>
#include <string>
using namespace std;

// 前向声明：观察者需知道被观察者
class Subject;

// 1. 观察者抽象类
class Observer {
public:
    virtual void update(const Subject& sub) = 0; // 接收被观察者通知
    virtual ~Observer() {}
};

// 2. 被观察者抽象类
class Subject {
public:
    void attach(Observer* obs) { // 注册观察者
        if (obs) _observers.push_back(obs);
    }
    void detach(Observer* obs) { // 移除观察者
        _observers.remove(obs);
    }
    void notify() { // 通知所有观察者
        for (auto obs : _observers) {
            obs->update(*this);
        }
    }
    virtual int getStatus() const = 0; // 供观察者获取状态
    virtual void setStatus(int s) = 0;
    virtual ~Subject() {}
private:
    list<Observer*> _observers; // 观察者列表
};

// 3. 具体被观察者（如“天气预报主题”）
class ConcreteSubject : public Subject {
public:
    int getStatus() const override { return _status; }
    void setStatus(int s) override {
        _status = s;
        notify(); // 状态变化时自动通知
    }
private:
    int _status; // 状态（如温度）
};

// 4. 具体观察者（如“手机APP”“电视端”）
class ConcreteObserver : public Observer {
public:
    ConcreteObserver(string name) : _name(name) {}
    void update(const Subject& sub) override {
        // 响应通知：获取被观察者状态并处理
        cout << _name << " 收到更新，当前状态：" << sub.getStatus() << endl;
    }
private:
    string _name;
};

// 使用示例
void test() {
    unique_ptr<Subject> sub = make_unique<ConcreteSubject>();
    unique_ptr<Observer> obs1 = make_unique<ConcreteObserver>("手机APP");
    unique_ptr<Observer> obs2 = make_unique<ConcreteObserver>("电视端");

    sub->attach(obs1.get());
    sub->attach(obs2.get());

    sub->setStatus(25); // 状态变化→自动通知
    sub->detach(obs2.get()); // 移除电视端
    sub->setStatus(30); // 仅手机APP收到
}

优缺点

使用场景

• 一个对象变化需触发多个对象更新（如 GUI 事件、日志系统、消息通知）；
• 主题与观察者松耦合（如微信公众号、天气预报推送）。

6. 策略模式

核心定义

定义 “一系列算法”，将每个算法封装为独立类，使算法可动态切换（算法族与使用算法的客户端解耦）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <memory>
using namespace std;

// 1. 策略抽象类（算法接口）
class Strategy {
public:
    virtual void execute() = 0; // 算法执行接口
    virtual ~Strategy() {}
};

// 2. 具体策略（不同算法实现）
class StrategyA : public Strategy { // 算法A（如支付宝支付）
public:
    void execute() override {
        cout << "策略A：执行支付宝支付" << endl;
    }
};
class StrategyB : public Strategy { // 算法B（如微信支付）
public:
    void execute() override {
        cout << "策略B：执行微信支付" << endl;
    }
};

// 3. 上下文（使用算法的客户端）
class Context {
public:
    Context(Strategy* stra) : _strategy(stra) {}
    void setStrategy(Strategy* stra) { // 动态切换策略
        _strategy = stra;
    }
    void doOperation() { // 调用策略的算法
        if (_strategy) _strategy->execute();
    }
private:
    Strategy* _strategy; // 策略指针（多态）
};

// 使用示例
void test() {
    // 初始用策略A
    unique_ptr<Strategy> sa = make_unique<StrategyA>();
    Context ctx(sa.get());
    ctx.doOperation();

    // 动态切换为策略B
    unique_ptr<Strategy> sb = make_unique<StrategyB>();
    ctx.setStrategy(sb.get());
    ctx.doOperation();
}

优缺点

使用场景

• 多种同类算法需切换（如排序算法、支付方式、压缩算法）；
• 避免用 if-else 堆砌算法（如 “if 支付宝→xxx else if 微信→xxx”）；
• 算法需独立扩展（如新增 “银行卡支付” 仅需加 StrategyC）。

7. 模板方法模式

核心定义

定义 “算法骨架”：在抽象基类中固定算法的步骤流程，将可变步骤延迟到子类实现（整体流程稳定，局部细节可变）。

类图关系（文字描述）

核心代码

#include <iostream>
using namespace std;

// 1. 抽象基类：定义算法骨架
class AbstractReport {
public:
    // 模板方法（核心：固定算法流程，不可重写）
    void generateReport() final {
        collectData();   // 步骤1：固定实现
        processData();   // 步骤2：可变实现（纯虚）
        formatReport();  // 步骤3：固定实现
        saveReport();    // 步骤4：默认实现（可重写）
    }
    virtual ~AbstractReport() {}
protected:
    // 固定步骤：基类实现，子类无需改
    void collectData() { cout << "1. 收集数据" << endl; }
    void formatReport() { cout << "3. 格式化报告为PDF" << endl; }

    // 可变步骤1：纯虚函数，子类必须实现
    virtual void processData() = 0;

    // 可变步骤2：默认实现，子类可重写
    virtual void saveReport() { cout << "4. 保存到服务器" << endl; }
};

// 2. 具体子类1：实现可变步骤
class SalesReport : public AbstractReport {
protected:
    void processData() override { // 实现纯虚步骤
        cout << "2. 处理销售数据：计算销售额" << endl;
    }
    // 不重写saveReport，用默认实现
};

// 3. 具体子类2：实现可变步骤+重写默认步骤
class InventoryReport : public AbstractReport {
protected:
    void processData() override { // 实现纯虚步骤
        cout << "2. 处理库存数据：分析缺货商品" << endl;
    }
    void saveReport() override { // 重写默认步骤
        cout << "4. 保存到本地数据库" << endl;
    }
};

// 使用示例
void test() {
    SalesReport sales;
    cout << "=== 生成销售报告 ===" << endl;
    sales.generateReport();

    InventoryReport inventory;
    cout << "\n=== 生成库存报告 ===" << endl;
    inventory.generateReport();
}

优缺点

使用场景

• 算法流程稳定，仅部分步骤可变（如报告生成、流程审批、游戏角色技能释放）；
• 多个子类有相似流程，仅细节不同（如不同报表的生成、不同支付的校验）。

8. 职责链模式

核心定义

将请求的 “处理者” 连成链，请求沿链传递，直到有处理者能处理（解耦请求发送者与接收者，无需知谁处理）。

类图关系（文字描述）

核心代码

#include <iostream>
#include <string>
#include <memory>
using namespace std;

// 1. 请求类：封装请求信息
class Request {
public:
    Request(string name, int amount) : _name(name), _amount(amount) {}
    string getName() const { return _name; }
    int getAmount() const { return _amount; }
private:
    string _name;   // 请求人
    int _amount;    // 请求金额（如加薪金额）
};

// 2. 抽象处理者
class Approver {
public:
    Approver() : _next(nullptr) {}
    void setNext(Approver* next) { // 设置下一个处理者
        _next = next;
    }
    virtual void handleRequest(const Request& req) = 0; // 处理请求
    virtual ~Approver() {}
protected:
    Approver* _next; // 下一个处理者（链的节点）
};

// 3. 具体处理者1：部门经理（处理≤1000）
class DeptManager : public Approver {
public:
    void handleRequest(const Request& req) override {
        if (req.getAmount() <= 1000) {
            cout << "部门经理审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        } else if (_next) {
            _next->handleRequest(req); // 无法处理，传下家
        } else {
            cout << "无人审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        }
    }
};

// 4. 具体处理者2：总监（处理1001~5000）
class Director : public Approver {
public:
    void handleRequest(const Request& req) override {
        if (req.getAmount() > 1000 && req.getAmount() <= 5000) {
            cout << "总监审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        } else if (_next) {
            _next->handleRequest(req);
        } else {
            cout << "无人审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        }
    }
};

// 5. 具体处理者3：总经理（处理>5000）
class GM : public Approver {
public:
    void handleRequest(const Request& req) override {
        if (req.getAmount() > 5000) {
            cout << "总经理审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        } else if (_next) {
            _next->handleRequest(req);
        } else {
            cout << "无人审批：" << req.getName() << " 加薪" << req.getAmount() << "元" << endl;
        }
    }
};

// 使用示例
void test() {
    // 创建处理者并连成链：部门经理→总监→总经理
    unique_ptr<Approver> dept = make_unique<DeptManager>();
    unique_ptr<Approver> dir = make_unique<Director>();
    unique_ptr<Approver> gm = make_unique<GM>();
    dept->setNext(dir.get());
    dir->setNext(gm.get());

    // 发送请求
    Request req1("张三", 800);   // 部门经理处理
    Request req2("李四", 3000);  // 总监处理
    Request req3("王五", 6000);  // 总经理处理
    Request req4("赵六", 10000); // 无人处理（链尾无下家）

    dept->handleRequest(req1);
    dept->handleRequest(req2);
    dept->handleRequest(req3);
    dept->handleRequest(req4);
}

优缺点

使用场景

• 请求需多个处理者分级处理（如审批流程、日志分级打印、异常处理）；
• 不确定谁处理请求（如 HTTP 请求路由、事件冒泡）；
• 需动态调整处理者（如插件化处理链）。

9. 命令模式

核心定义

将 “请求” 封装为对象，使请求的发送者（调用者）与接收者解耦：调用者只需调用命令对象的 “执行” 方法，无需知接收者如何处理。

类图关系（文字描述）

核心代码

#include <iostream>
#include <list>
#include <memory>
using namespace std;

// 1. 接收者：实现具体业务（如“厨师”）
class Cook {
public:
    void cookFish() { cout << "厨师：做红烧鱼" << endl; }
    void cookMeat() { cout << "厨师：做锅包肉" << endl; }
};

// 2. 命令抽象类
class Command {
public:
    Command(Cook* cook) : _cook(cook) {}
    virtual void execute() = 0; // 命令执行接口
    virtual ~Command() {}
protected:
    Cook* _cook; // 接收者（命令需知谁执行）
};

// 3. 具体命令：绑定“命令→接收者方法”
class FishCommand : public Command {
public:
    FishCommand(Cook* cook) : Command(cook) {}
    void execute() override {
        _cook->cookFish(); // 命令对应接收者的“做鱼”方法
    }
};
class MeatCommand : public Command {
public:
    MeatCommand(Cook* cook) : Command(cook) {}
    void execute() override {
        _cook->cookMeat(); // 命令对应接收者的“做肉”方法
    }
};

// 4. 调用者：发起命令（如“服务员”）
class Waiter {
public:
    void addCommand(Command* cmd) { // 添加命令到列表
        if (cmd) _commands.push_back(cmd);
    }
    void notify() { // 通知执行所有命令
        for (auto cmd : _commands) {
            cmd->execute();
        }
    }
private:
    list<Command*> _commands; // 命令列表（支持批量执行）
};

// 使用示例
void test() {
    // 1. 创建接收者（厨师）
    unique_ptr<Cook> cook = make_unique<Cook>();

    // 2. 创建命令（订单），绑定接收者
    unique_ptr<Command> cmd1 = make_unique<FishCommand>(cook.get());
    unique_ptr<Command> cmd2 = make_unique<MeatCommand>(cook.get());

    // 3. 调用者（服务员）添加命令并执行
    unique_ptr<Waiter> waiter = make_unique<Waiter>();
    waiter->addCommand(cmd1.get());
    waiter->addCommand(cmd2.get());
    waiter->notify(); // 服务员通知厨师执行订单
}

优缺点

使用场景

• 需解耦请求发送与接收（如 GUI 按钮→业务逻辑、遥控器→家电）；
• 需支持撤销 / 重做（如文本编辑器、游戏存档）；
• 需批量 / 延迟执行请求（如任务队列、事务提交）；
• 需日志记录请求（如审计日志、命令回放）。

总结：设计模式选择指南

设计模式的核心不是 “套用模板”，而是理解其 “解耦、复用、扩展” 的设计思想，根据实际场景灵活选择。