GoF 23种经典的设计模式——抽象工厂模式
GoF 23种经典的设计模式——抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或依赖对象的家族，而无需指定具体的类。
在抽象工厂模式中，我们定义一个抽象工厂接口，该接口声明了一组用于创建不同产品对象的方法。每个具体工厂类都实现了抽象工厂接口，并负责创建特定的产品对象。这样，通过抽象工厂接口，我们可以在不涉及具体类的情况下，通过工厂来创建一系列相关的产品对象。
抽象工厂模式的参与者：
- 抽象工厂（Abstract Factory）：定义了创建产品对象的接口，它包含一组创建不同产品的方法。
- 具体工厂（Concrete Factory）：实现了抽象工厂接口，每个具体工厂类负责创建一个完整的产品家族。
- 抽象产品（Abstract Product）：定义了产品对象的接口，具体产品对象将实现这些接口。
- 具体产品（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 模式更关注创建一类对象，通过将对象的创建延迟到子类中实现。
------本页内容已结束，喜欢请分享------