问题的提出
从前面我们已经使用了工厂方法模式 解决了一些问题。
现在 策划又提出了新的需求：对于各个怪物，在不同的场景下，怪物的面板数值会发生变化，
//怪物分类：亡灵类，元素类，机械类
//战斗场景分类：沼泽地区，山脉地区，城镇。
那么就有9类怪物====>沼泽地亡灵类、元素类、机械类，山脉地区亡灵类、元素类、机械类，城镇中的亡灵类、元素类、机械类
//工厂方法模式：一个工厂创建一种类怪物。我们就要创建9个工厂了。
抽象模式的核心思想
//但如果一个工厂子类能够创建不止一种而是多种具有相同规则的怪物对象，那么就可以有效的减少所创建的工厂子类数量，这就是抽象工厂模式的核心思想。
两个概念：a)产品等级结构 b)产品族
在这里，我们先要弄清楚 两个概念：a)产品等级结构 b)产品族
//抽象工厂模式是按照产品族来生产 产品（产地相同的用一个工厂来生产）------一个地点有一个工厂，该工厂负责生产本产地的所有产品。
代码实现
第一步：肯定是先将9个类先弄出来
第二步：第二步，定义一个抽象工厂类
//所有工厂类的父类
第三步：具体沼泽地区的工厂
#include <iostream>
using namespace std;
namespace _namespace1 {
//第一步，定义9个怪物和其父类
//怪物父类
class Monster
{
public:
//构造函数
Monster(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
virtual ~Monster() {} //做父类时析构函数应该为虚函数
protected://可能被子类访问的成员，所以用protected修饰
//怪物属性
int m_life; //生命值
int m_magic; //魔法值
int m_attack; //攻击力
};
//沼泽亡灵类怪物
class M_Undead_Swamp :public Monster
{
public:
M_Undead_Swamp(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个沼泽的亡灵类怪物来到了这个世界" << endl;
}
};
//沼泽元素类怪物
class M_Element_Swamp :public Monster
{
public:
M_Element_Swamp(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个沼泽的元素类怪物来到了这个世界" << endl;
}
};
//沼泽机械类怪物
class M_Mechanic_Swamp :public Monster
{
public:
M_Mechanic_Swamp(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个沼泽的机械类怪物来到了这个世界" << endl;
}
};
//--------------------------
//山脉亡灵类怪物
class M_Undead_Mountain :public Monster
{
public:
M_Undead_Mountain(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个山脉的亡灵类怪物来到了这个世界" << endl;
}
};
//山脉元素类怪物
class M_Element_Mountain :public Monster
{
public:
M_Element_Mountain(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个山脉的元素类怪物来到了这个世界" << endl;
}
};
//山脉机械类怪物
class M_Mechanic_Mountain :public Monster
{
public:
M_Mechanic_Mountain(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个山脉的机械类怪物来到了这个世界" << endl;
}
};
//--------------------------
//城镇亡灵类怪物
class M_Undead_Town :public Monster
{
public:
M_Undead_Town(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个城镇的亡灵类怪物来到了这个世界" << endl;
}
};
//城镇元素类怪物
class M_Element_Town :public Monster
{
public:
M_Element_Town(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个城镇的元素类怪物来到了这个世界" << endl;
}
};
//城镇机械类怪物
class M_Mechanic_Town :public Monster
{
public:
M_Mechanic_Town(int life, int magic, int attack) :Monster(life, magic, attack)
{
cout << "一个城镇的机械类怪物来到了这个世界" << endl;
}
};
//如上已经把9个怪物定义出来了
//第二步，定义一个抽象工厂类
//所有工厂类的父类
class M_ParFactory
{
public:
virtual Monster* createMonster_Undead() = 0; //创建亡灵类怪物
virtual Monster* createMonster_Element() = 0; //创建元素类怪物
virtual Monster* createMonster_Mechanic() = 0; //创建机械类怪物
virtual ~M_ParFactory() {} //做父类时析构函数应该为虚函数
};
//沼泽地区的工厂
class M_Factory_Swamp :public M_ParFactory
{
public:
virtual Monster* createMonster_Undead()
{
return new M_Undead_Swamp(300, 50, 120); //创建沼泽亡灵类怪物
}
virtual Monster* createMonster_Element()
{
return new M_Element_Swamp(200, 80, 110); //创建沼泽元素类怪物
}
virtual Monster* createMonster_Mechanic()
{
return new M_Mechanic_Swamp(400, 0, 90); //创建沼泽机械类怪物
}
};
//--------------------------
//山脉地区的工厂
class M_Factory_Mountain :public M_ParFactory
{
public:
virtual Monster* createMonster_Undead()
{
return new M_Undead_Mountain(300, 50, 80); //创建山脉亡灵类怪物
}
virtual Monster* createMonster_Element()
{
return new M_Element_Mountain(200, 80, 100); //创建山脉元素类怪物
}
virtual Monster* createMonster_Mechanic()
{
return new M_Mechanic_Mountain(600, 0, 110); //创建山脉机械类怪物
}
};
//--------------------------
//城镇的工厂
class M_Factory_Town :public M_ParFactory
{
public:
virtual Monster* createMonster_Undead()
{
return new M_Undead_Town(300, 50, 80); //创建城镇亡灵类怪物
}
virtual Monster* createMonster_Element()
{
return new M_Element_Town(200, 80, 100); //创建城镇元素类怪物
}
virtual Monster* createMonster_Mechanic()
{
return new M_Mechanic_Town(400, 0, 110); //创建城镇机械类怪物
}
};
}
int main() {
_namespace1::M_ParFactory* p_mou_fy = new _namespace1::M_Factory_Mountain(); //多态工厂，山脉地区的工厂
_namespace1::Monster* pM1 = p_mou_fy->createMonster_Element(); //创建山脉地区的元素类怪物
_namespace1::M_ParFactory* p_twn_fy = new _namespace1::M_Factory_Town(); //多态工厂，城镇的工厂
_namespace1::Monster* pM2 = p_twn_fy->createMonster_Undead(); //创建城镇地区的亡灵类怪物
_namespace1::Monster* pM3 = p_twn_fy->createMonster_Mechanic(); //创建城镇地区的机械类怪物
//释放资源
//释放工厂
delete p_mou_fy;
delete p_twn_fy;
delete pM1;
delete pM2;
delete pM3;
return 0;
}
第二个例子：
不同厂商生产不同部件范例
//芭比娃娃：身体（包括头、颈部、躯干、四肢）、衣服、鞋子
//中国，日本，美国 厂商
//要求：制作两个芭比娃娃，第一个：身体，衣服，鞋子，全部采用中国厂商制造的部件。
//第二个：身体采用中国厂商，衣服部件采用日本厂商，鞋子部件采用美国厂商。
//类的设计思路：
//a)将身体，衣服，鞋子 这三个部件实现为抽象类。
//b)实现一个抽象工厂，分别用来生产身体、衣服、鞋子这三个部件。
//c)针对不同厂商的每个部件实现具体的类以及每个厂商所代表的具体工厂。
namespace _nmsp3
{
//身体抽象类
class Body
{
public:
virtual void getName() = 0;
virtual ~Body() {}
};
//衣服抽象类
class Clothes
{
public:
virtual void getName() = 0;
virtual ~Clothes() {}
};
//鞋子抽象类
class Shoes
{
public:
virtual void getName() = 0;
virtual ~Shoes() {}
};
//---------------------------
//抽象工厂类
class AbstractFactory
{
public:
//所创建的部件应该稳定的保持这三个部件，才适合抽象工厂模式
virtual Body* createBody() = 0; //创建身体
virtual Clothes* createClothes() = 0; //创建衣服
virtual Shoes* createShoes() = 0; //创建鞋子
virtual ~AbstractFactory() {}
};
//---------------------------
//芭比娃娃类
class BarbieDoll
{
public:
//构造函数
BarbieDoll(Body* tmpbody, Clothes* tmpclothes, Shoes* tmpshoes)
{
body = tmpbody;
clothes = tmpclothes;
shoes = tmpshoes;
}
void Assemble() //组装芭比娃娃
{
cout << "成功组装了一个芭比娃娃：" << endl;
body->getName();
clothes->getName();
shoes->getName();
}
private:
Body* body;
Clothes* clothes;
Shoes* shoes;
};
//---------------------------
//中国厂商实现的三个部件
class China_Body :public Body
{
public:
virtual void getName()
{
cout << "中国厂商产的_身体部件" << endl;
}
};
class China_Clothes :public Clothes
{
public:
virtual void getName()
{
cout << "中国厂商产的_衣服部件" << endl;
}
};
class China_Shoes :public Shoes
{
public:
virtual void getName()
{
cout << "中国厂商产的_鞋子部件" << endl;
}
};
//创建一个中国工厂
class ChinaFactory : public AbstractFactory
{
public:
virtual Body* createBody()
{
return new China_Body;
}
virtual Clothes* createClothes()
{
return new China_Clothes;
}
virtual Shoes* createShoes()
{
return new China_Shoes;
}
};
//---------------------------
//日本厂商实现的三个部件
class Japan_Body :public Body
{
public:
virtual void getName()
{
cout << "日本厂商产的_身体部件" << endl;
}
};
class Japan_Clothes :public Clothes
{
public:
virtual void getName()
{
cout << "日本厂商产的_衣服部件" << endl;
}
};
class Japan_Shoes :public Shoes
{
public:
virtual void getName()
{
cout << "日本厂商产的_鞋子部件" << endl;
}
};
//创建一个日本工厂
class JapanFactory : public AbstractFactory
{
public:
virtual Body* createBody()
{
return new Japan_Body;
}
virtual Clothes* createClothes()
{
return new Japan_Clothes;
}
virtual Shoes* createShoes()
{
return new Japan_Shoes;
}
};
//---------------------------
//美国厂商实现的三个部件
class America_Body :public Body
{
public:
virtual void getName()
{
cout << "美国厂商产的_身体部件" << endl;
}
};
class America_Clothes :public Clothes
{
public:
virtual void getName()
{
cout << "美国厂商产的_衣服部件" << endl;
}
};
class America_Shoes :public Shoes
{
public:
virtual void getName()
{
cout << "美国厂商产的_鞋子部件" << endl;
}
};
//创建一个美国工厂
class AmericaFactory : public AbstractFactory
{
public:
virtual Body* createBody()
{
return new America_Body;
}
virtual Clothes* createClothes()
{
return new America_Clothes;
}
virtual Shoes* createShoes()
{
return new America_Shoes;
}
};
}
int main() {
//创建第一个芭比娃娃------------
//(1)创建一个中国工厂
_nmsp3::AbstractFactory* pChinaFactory = new _nmsp3::ChinaFactory();
//(2)创建中国产的各种部件
_nmsp3::Body* pChinaBody = pChinaFactory->createBody();
_nmsp3::Clothes* pChinaClothes = pChinaFactory->createClothes();
_nmsp3::Shoes* pChinaShoes = pChinaFactory->createShoes();
//(3)创建芭比娃娃
_nmsp3::BarbieDoll* pbd1obj = new _nmsp3::BarbieDoll(pChinaBody, pChinaClothes, pChinaShoes);
pbd1obj->Assemble(); //组装芭比娃娃
cout << "-------------------------------------" << endl;
//创建第二个芭比娃娃------------
//(1)创建另外两个工厂：日本工厂，美国工厂
_nmsp3::AbstractFactory* pJapanFactory = new _nmsp3::JapanFactory();
_nmsp3::AbstractFactory* pAmericaFactory = new _nmsp3::AmericaFactory();
//(2)创建中国产的身体部件，日本产的衣服部件，美国产的鞋子部件
_nmsp3::Body* pChinaBody2 = pChinaFactory->createBody();
_nmsp3::Clothes* pJapanClothes = pJapanFactory->createClothes();
_nmsp3::Shoes* pAmericaShoes = pAmericaFactory->createShoes();
//(3)创建芭比娃娃
_nmsp3::BarbieDoll* pbd2obj = new _nmsp3::BarbieDoll(pChinaBody2, pJapanClothes, pAmericaShoes);
pbd2obj->Assemble(); //组装芭比娃娃
//最后记得释放内存----------------
delete pbd1obj;
delete pChinaShoes;
delete pChinaClothes;
delete pChinaBody;
delete pChinaFactory;
//------------
delete pbd2obj;
delete pAmericaShoes;
delete pJapanClothes;
delete pChinaBody2;
delete pAmericaFactory;
delete pJapanFactory;
return 0;
}工厂方法模式 和 抽象工厂模式的区别
//工厂方法模式和抽象工厂模式区别：
//a)工厂方法模式:一个工厂生产一个产品
//b)抽象工厂模式:一个工厂生产多个产品（产品族）
//抽象工厂模式的定义（实现意图）：提供一个接口（AbstractFactory），
//让该接口负责创建一系列相关或者相互依赖的对象(Body,Clothes,Shoes)，而无需指定他们具体的类。