设计模式-抽象工厂模式

学习笔记：抽象工厂模式

模式简介

：属于创建型模式，提供了一种创建对象的最佳方式。

为什么用

：使用工厂模式会产生很多工厂，但我不想申请具体的工厂，来个总的管理，说句，嘿，工厂管理者，我要名为xxx的工厂。

怎么样用

：按之前的抽象工厂模式设计出多个Factory类的生产函数，在写一个总的Factory类，进行管理。

注意事项

：这就是一个工厂生产具体的工厂，具体的工厂生产具体的对象的过程。c++要实现，得让所有的工厂有一个共同的父类，每个工厂实现父类的不同方法。

实际举例

：实现角色的不同攻击方式

#include <iostream>
using namespace std;

//父类技能
class Skill {
public:
	virtual void attack() {
		cout << "待实现的技能攻击\n";
	};
};

//子类技能
class  SubSkill_1 : public Skill {
	void attack() {
		cout << "moota:发动 [重击] 技能，攻击了怪物\n";
	};
};
class  SubSkill_2 : public Skill {
	void attack() {
		cout << "moota:发动 [三连击] 技能，攻击了怪物\n";
	};
};
class  SubSkill_3 : public Skill {
	void attack() {
		cout << "moota:发动 [反击] 技能，攻击了怪物\n";
	};
};

//父类普攻
class General {
public:
	virtual void attack() {
		cout << "待实现的普攻效果\n";
	};
};

//子类普攻
class  SubGeneral_1 : public General {
	void attack() {
		cout << "moota:发动 [近程物理] 普攻，攻击了怪物\n";
	};
};
class  SubGeneral_2 : public General {
	void attack() {
		cout << "moota:发动 [远程物理] 普攻，攻击了怪物\n";
	};
};
class  SubGeneral_3 : public General {
	void attack() {
		cout << "moota:发动 [魔法] 普攻，攻击了怪物\n";
	};
};

//攻击工厂 对简单工厂写一个总的父类，实现多态，即抽象工厂
class AttackFactory {
public:
	Skill* skill;
	General* general;
	virtual Skill* getSkill(string name) {
		skill = new Skill();
		return skill;
	}
	virtual General* getGeneral(string name) {
		general = new General();
		return general;
	}
};

//技能工厂 实现攻击工厂的getSkill方法
class SkillFactory :public  AttackFactory {
public:
	//待使用技能
	Skill* skill;
	//设置待使用技能并返回技能
	Skill* getSkill(string name) {
		if (name == "重击") {
			skill = new SubSkill_1();
		}
		else if (name == "三连击") {
			skill = new SubSkill_2();
		}
		else if (name == "反击") {
			skill = new SubSkill_3();
		}
		else {
			skill = new Skill();
		}
		return skill;
	}
};
//普攻工厂 实现攻击工厂的getGeneral方法
class GeneralFactory :public  AttackFactory {
public:
	//待使用普攻
	General* general;
	//设置待使用普攻并返回普攻
	General* getGeneral(string name) {
		if (name == "近战") {
			general = new SubGeneral_1();
		}
		else if (name == "远程") {
			general = new SubGeneral_2();
		}
		else if (name == "魔法") {
			general = new SubGeneral_3();
		}
		else {
			general = new General();
		}
		return general;
	}
};

//攻击工厂是抽象的，给予不同的字符串来创建具体的工厂
class AttackFactoryCreater {
public:
	AttackFactory* attackFactory;
	AttackFactory* getAttackFactory(string name) {
		if (name == "技能") {
			attackFactory = new SkillFactory();
		}
		else if (name == "普攻") {
			attackFactory = new GeneralFactory();
		}
		else {
			attackFactory = new AttackFactory();
		}
		return attackFactory;
	}
};

int main()
{
	//生产攻击工厂的管理者
	AttackFactoryCreater attackFactoryCreater;

	//生产技能工厂
	AttackFactory* skillFactory = attackFactoryCreater.getAttackFactory("技能");
	//生产技能
	Skill* skill = skillFactory->getSkill("重击");
	//使用技能
	skill->attack();

	//生产普攻工厂
	AttackFactory* generalFactory = attackFactoryCreater.getAttackFactory("普攻");
	//生产普攻
	General* general = generalFactory->getGeneral("近战");
	//使用普攻
	general->attack();

	//其他测试
	skill = skillFactory->getSkill("三连击");
	skill->attack();
	general = generalFactory->getGeneral("远程");
	general->attack();
	general = generalFactory->getGeneral("魔法");
	general->attack();
	skill = skillFactory->getSkill("反击");
	skill->attack();
	return 0;
}