GoF 23种经典的设计模式——抽象工厂模式

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或依赖对象的家族，而无需指定具体的类。

在抽象工厂模式中，我们定义一个抽象工厂接口，该接口声明了一组用于创建不同产品对象的方法。每个具体工厂类都实现了抽象工厂接口，并负责创建特定的产品对象。这样，通过抽象工厂接口，我们可以在不涉及具体类的情况下，通过工厂来创建一系列相关的产品对象。

抽象工厂模式的参与者：

1. 抽象工厂（Abstract Factory）：定义了创建产品对象的接口，它包含一组创建不同产品的方法。
2. 具体工厂（Concrete Factory）：实现了抽象工厂接口，每个具体工厂类负责创建一个完整的产品家族。
3. 抽象产品（Abstract Product）：定义了产品对象的接口，具体产品对象将实现这些接口。
4. 具体产品（Concrete Product）：实现了抽象产品接口，是由具体工厂创建的对象。

假设我们要开发一款游戏，采用这样一种处理策略：为游戏设立等级，初级、中级、高级关卡。每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建高级的怪物，反之也不可以。 AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

首先，定义两个抽象产品类 MonsterA MonsterB 表示两种怪兽，A 声明了一个纯虚函数 attack() 用于怪物攻击玩家，B 声明一个纯虚函数 debuff() 用于怪物给玩家上 debuff：

class Monster {
public:
    virtual void attack() = 0;
};

class Monster {
public:
    virtual void debuff() = 0;
};

然后，我们定义具体产品类，例如 BeginnerMonsterA、IntermediateMonsterA 和 AdvancedMonsterA，它们分别实现了 MonsterA 接口：

class BeginnerMonsterA : public MonsterA {
public:
    void attack() override {
        cout << "Beginner monster is attacking." << endl;
    }
};

class IntermediateMonsterA : public MonsterA {
public:
    void attack() override {
        cout << "Intermediate monster is attacking." << endl;
    }
};

class AdvancedMonsterA : public MonsterA {
public:
    void attack() override {
        cout << "Advanced monster is attacking." << endl;
    }
};

BeginnerMonsterB、IntermediateMonsterB 和 AdvancedMonsterB，它们分别实现了 MonsterB 接口：

class BeginnerMonsterB : public MonsterB {
public:
    void debuff() override {
        cout << "Beginner monster is debuffing." << endl;
    }
};

class IntermediateMonsterB : public MonsterB {
public:
    void debuff() override {
        cout << "Intermediate monster is debuffing." << endl;
    }
};

class AdvancedMonsterB : public MonsterB {
public:
    void debuff() override {
        cout << "Advanced monster is debuffing." << endl;
    }
};

接下来，我们定义抽象工厂类 AbstractFactory，它声明了创建两种怪物的抽象方法：

class AbstractFactory {
public:
    virtual MonsterA* createMonsterA() = 0;
    virtual MonsterB* createMonsterB() = 0;
};

然后，定义具体工厂类 ConcreteFactoryBeginner，它实现了 AbstractFactory 接口，负责创建简单难度的具体的怪物对象：

class ConcreteFactoryBeginner : public AbstractFactory {
public:
    MonsterA* createBeginnerMonster() override {
        return new BeginnerMonsterA();
    }

    MonsterB* createIntermediateMonster() override {
        return new BeginnerMonsterB();
    }
};

创建中等和困难难度的怪物对象的实现也类似。

现在，我们可以使用抽象工厂模式来创建不同等级的怪物实例。以下是一个简单的示例，在初级关卡中创建初级的所有怪物种类：

int main() {
    AbstractFactory* factory = new ConcreteFactoryBeginner();

    Monster* beginnerMonsterA = factory->createBeginnerMonsterA();
    beginnerMonster->attack();

    Monster* beginnerMonsterB = factory->createBeginnerMonsterB();
    beginnerMonster->attack();

    delete beginnerMonsterA;
    delete beginnerMonsterB;
    delete factory;

    return 0;
}

Abstract Factory 模式更关注创建一族对象（不同的怪物），通常具有共同的主题（相同的难度系数），而 Factory 模式更关注创建一类对象，通过将对象的创建延迟到子类中实现。