【设计模式】抽象工厂：打造你的全能装备生产线_抽象工厂模式游戏中的装备套装-CSDN博客

本文链接：https://blog.csdn.net/wwb123321/article/details/146244048

设计模式是软件开发中的一种宝贵财富，它们为我们提供了经过验证的解决方案，帮助我们应对常见的软件设计难题。今天，我们将一起探索抽象工厂模式（Abstract Factory Pattern），一种强大的创建型设计模式。通过这篇公众号文章，你将深入理解抽象工厂模式的核心概念，并通过生动的代码示例和实际应用场景，轻松掌握这一模式的使用方式。准备好了吗？让我们开始这场设计模式之旅吧！

一、什么是抽象工厂模式？

抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或依赖的对象，而不需要指定这些对象的具体类。听起来有点抽象？别急，我们用一个有趣的例子来解释。

游戏角色装备工厂：一个生动的比喻

游戏角色抽象工厂
想象你正在开发一款角色扮演游戏（RPG），游戏中有三种角色：战士、法师和弓箭手。每个角色都有自己的武器和技能：

战士手持剑，擅长盾牌防御。
法师挥舞法杖，能施放火球术。
弓箭手使用弓箭，掌握隐身技巧。

现在，假设你需要在游戏中为这些角色配备相应的武器和技能。如果手动为每个角色创建这些装备，你可能会写出这样的代码：

Weapon* warriorWeapon = new Sword();
Skill* warriorSkill = new ShieldDefense();
Weapon* mageWeapon = new Staff();
Skill* mageSkill = new Fireball();

这样写虽然可行，但问题在于：如果游戏增加了新角色（比如“盗贼”），或者需要调整装备组合，你得频繁修改代码。抽象工厂模式就像一个“装备生产线”，它能帮你批量生产一系列相关对象，而无需关心具体细节。

在抽象工厂模式中，我们会定义一个抽象工厂类，声明创建武器和技能的接口。然后，通过具体的工厂类（比如战士工厂、法师工厂）来实现这些方法。这样，你只需告诉工厂“我需要一个战士的装备”，它就会自动为你准备好剑和盾牌防御技能。是不是很酷？

二、抽象工厂模式 vs. 简单工厂 vs. 工厂方法模式

在深入代码之前，我们先来对比一下简单工厂、工厂方法模式和抽象工厂模式，看看它们有何不同。

1. 简单工厂模式：基础版生产线

相关文章：【设计模式】简单工厂：让你的代码像点餐一样简单！
简单工厂是最基础的工厂模式，它通过一个工厂类来创建不同的产品对象。比如：

class WeaponFactory {
public:
    Weapon* createWeapon(string type) {
        if (type == "sword") return new Sword();
        if (type == "staff") return new Staff();
        if (type == "bow") return new Bow();
        return nullptr;
    }
};

优点：简单直观，适合小型场景。

缺点：如果想添加新武器（比如“匕首”），需要修改createWeapon方法，违反了开闭原则（对扩展开放，对修改关闭）。

2. 工厂方法模式：升级版生产线

相关文章：【设计模式】工厂方法：从交通工具系统看设计的奥秘
工厂方法模式改进了简单工厂，把创建具体产品的任务交给子类。比如：

class WeaponFactory {
public:
    virtual Weapon* createWeapon() = 0;
};

class SwordFactory : public WeaponFactory {
public:
    Weapon* createWeapon() override { return new Sword(); }
};

优点：新增武器时，只需增加新的工厂子类，无需改动现有代码，符合开闭原则。

缺点：只能创建单一类型的产品（比如只管武器，不涉及技能）。

3. 抽象工厂模式：全能生产线

抽象工厂模式更进一步，它能创建一系列相关的产品（比如武器+技能）。它确保产品的组合是兼容的，比如战士的剑和盾牌防御总是搭配出现。
关键区别：

简单工厂：一个类负责所有产品创建，扩展性差。
工厂方法：一个工厂负责一种产品，扩展性好但功能单一。
抽象工厂：一个工厂负责一组相关产品，扩展性和一致性兼顾。

抽象工厂模式的C++实现

现在，让我们用C++实现一个完整的抽象工厂模式，基于前面的游戏角色例子。

1. 定义抽象产品类

首先，定义武器和技能的抽象基类：

#include <iostream>
using namespace std;

// 抽象武器
class Weapon {
public:
    virtual void attack() = 0;
    virtual ~Weapon() {}
};

// 抽象技能
class Skill {
public:
    virtual void use() = 0;
    virtual ~Skill() {}
};

2. 实现具体产品类

然后，定义具体的武器和技能：

// 具体武器：剑
class Sword : public Weapon {
public:
    void attack() override {
        cout << "使用剑进行攻击！" << endl;
    }
};

// 具体武器：法杖
class Staff : public Weapon {
public:
    void attack() override {
        cout << "使用法杖进行攻击！" << endl;
    }
};

// 具体武器：弓箭
class Bow : public Weapon {
public:
    void attack() override {
        cout << "使用弓箭进行攻击！" << endl;
    }
};

// 具体技能：盾牌防御
class ShieldDefense : public Skill {
public:
    void use() override {
        cout << "使用盾牌防御！" << endl;
    }
};

// 具体技能：火球术
class Fireball : public Skill {
public:
    void use() override {
        cout << "施放火球术！" << endl;
    }
};

// 具体技能：隐身
class Stealth : public Skill {
public:
    void use() override {
        cout << "进入隐身状态！" << endl;
    }
};

3. 定义抽象工厂类

接下来，定义抽象工厂，声明创建产品的方法：

// 抽象工厂
class CharacterFactory {
public:
    virtual Weapon* createWeapon() = 0;
    virtual Skill* createSkill() = 0;
    virtual ~CharacterFactory() {}
};

4. 实现具体工厂类

然后，创建具体的工厂类，为不同角色生产装备：

// 具体工厂：战士工厂
class WarriorFactory : public CharacterFactory {
public:
    Weapon* createWeapon() override {
        return new Sword();
    }
    Skill* createSkill() override {
        return new ShieldDefense();
    }
};

// 具体工厂：法师工厂
class MageFactory : public CharacterFactory {
public:
    Weapon* createWeapon() override {
        return new Staff();
    }
    Skill* createSkill() override {
        return new Fireball();
    }
};

// 具体工厂：弓箭手工厂
class ArcherFactory : public CharacterFactory {
public:
    Weapon* createWeapon() override {
        return new Bow();
    }
    Skill* createSkill() override {
        return new Stealth();
    }
};

5. 使用抽象工厂

最后，看看如何在代码中使用这些工厂：

int main() {
    // 创建战士装备
    CharacterFactory* warriorFactory = new WarriorFactory();
    Weapon* sword = warriorFactory->createWeapon();
    Skill* shield = warriorFactory->createSkill();
    sword->attack();    // 输出: 使用剑进行攻击！
    shield->use();      // 输出: 使用盾牌防御！
    delete sword;
    delete shield;
    delete warriorFactory;

    // 创建法师装备
    CharacterFactory* mageFactory = new MageFactory();
    Weapon* staff = mageFactory->createWeapon();
    Skill* fireball = mageFactory->createSkill();
    staff->attack();    // 输出: 使用法杖进行攻击！
    fireball->use();    // 输出: 施放火球术！
    delete staff;
    delete fireball;
    delete mageFactory;

    // 创建弓箭手装备
    CharacterFactory* archerFactory = new ArcherFactory();
    Weapon* bow = archerFactory->createWeapon();
    Skill* stealth = archerFactory->createSkill();
    bow->attack();      // 输出: 使用弓箭进行攻击！
    stealth->use();     // 输出: 进入隐身状态！
    delete bow;
    delete stealth;
    delete archerFactory;

    return 0;
}