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

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

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

227be19ed761

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

抽象工厂模式的参与者:

  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 模式更关注创建一类对象,通过将对象的创建延迟到子类中实现。

------本页内容已结束,喜欢请分享------

文章作者
能不能吃完饭再说
隐私政策
PrivacyPolicy
用户协议
UseGenerator
许可协议
NC-SA 4.0


© 版权声明
THE END
喜欢就支持一下吧
点赞26赞赏 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片