设计模式共23种,总共分为三大类:创建型模式,结构型模式,行为性模式
工厂模式属于创建型模式,其聚焦于如何组织类去实例化一个对象,实际上就是在原本直接的new的基础上进行一个封装,达到可以方便随时变更,扩展,和其他类交互的功能
简单工厂
简单工厂顾名思义,十分简单,基本思想就是创建一个工厂类用来管理某一类对象的实例化,用户只需要实例化一个工厂对象,并传入一个字符串或枚举来确定自己需要的对象,工厂就能自动构造出一个所需的对象,而创建这个对象的所有操作都会集中在工厂内进行,后期需要修改时也无需到处去替换,只需在工厂内修改。
代码定义了一个Unit基类,三种继承其的角色和一个用于创建三种角色的Factory类
从代码也很明显可以看出简单工厂的缺点,就是每次增加一个类,都需要去修改工厂内部的函数,不符合开闭原则,当类过多时也难以修改。当然如果类不多,那么简单工厂就足够使用了,毕竟正如其名,简单工厂
#include <iostream>
using namespace std;
namespace SimpleFactory
{
class Unit
{
public:
virtual void Call() = 0;
};
class Warrior : public Unit
{
public:
virtual void Call() override
{
cout << "I am Warrior!" << endl;
}
};
class Archer : public Unit
{
public:
virtual void Call() override
{
cout << "I am Archer!" << endl;
}
};
class Wizard : public Unit
{
public:
virtual void Call() override
{
cout << "I am Wizard!" << endl;
}
};
namespace EUnit
{
enum Type
{
Warrior,
Archer,
Wizard
};
}
//简单工厂(显然不符合开闭原则)
class UnitFactory
{
public:
Unit* CreateUnit(EUnit::Type unit)
{
switch(unit)
{
case EUnit::Warrior:
return new Warrior();
case EUnit::Archer:
return new Archer();
case EUnit::Wizard:
return new Wizard();
}
return nullptr;
}
};
}
int main()
{
//简单工厂
{
using namespace SimpleFactory;
UnitFactory factory;
Unit* warrior = factory.CreateUnit(EUnit::Warrior);
Unit* archer = factory.CreateUnit(EUnit::Archer);
Unit* wizard = factory.CreateUnit(EUnit::Wizard);
warrior->Call();
archer->Call();
wizard->Call();
}
}
工厂模式
工厂模式在简单工厂的基础上,遵循了开闭原则,即对修改关闭,对扩展开放,将增加支持的类的操作从修改函数变成了继承并写新的子类
即工厂模式提供了一个工厂基类,需要一种产品时就创建对应的工厂类
下述代码和简单工厂最大的不同就是创建了一个工厂类的接口,并实现了三种工厂对应三种单位,使用时创建对应的单位来创建所需的对象。
之所以这样看着感觉毫无意义徒增复杂度,是因为这只是最基础的代码框架,在每个子类和父类,和继承链条上的每一处都可以插入其他的函数来扩展创建时的功能,最简单的,如果你需要一个计数器来记录创建的对象数量,那么直接在工厂的父类中创建一个静态变量,或者创建一个专门的计数类,并在工厂中引用这个计数类,在创建时累加。这些都可以轻松做到
#include <iostream>
using namespace std;
namespace FactoryPattern
{
//通过定义接口进行使用
class IUnit
{
public:
virtual void Call() = 0;
virtual ~IUnit() {};
};
class IFactory
{
public:
virtual IUnit* Create() = 0;
};
class Warrior : public IUnit
{
public:
virtual void Call() override
{
cout << "I am Warrior!" << endl;
}
};
class Archer : public IUnit
{
public:
virtual void Call() override
{
cout << "I am Archer!" << endl;
}
};
class Wizard : public IUnit
{
public:
virtual void Call() override
{
cout << "I am Wizard!" << endl;
}
};
class WarriorFactory : public IFactory
{
public:
virtual IUnit* Create() override
{
return new Warrior();
}
};
class ArcherFactory : public IFactory
{
public:
virtual IUnit* Create() override
{
return new Archer();
}
};
class WizardFactory : public IFactory
{
public:
virtual IUnit* Create() override
{
return new Wizard();
}
};
}
int main()
{
//工厂模式
{
using namespace FactoryPattern;
IFactory* factorys[3];
factorys[0] = new WarriorFactory();
factorys[1] = new ArcherFactory();
factorys[2] = new WizardFactory();
for(int i = 0; i < 3; i++)
{
IUnit* unit = factorys[i]->Create();
unit->Call();
delete unit;
}
}
}
抽象工厂模式
上述工厂类,在使用过程中,因为每个产品类都需要一个对应的工厂类,这样在后期会导致工厂类的数量膨胀,其结果是同样也不好维护,最好的方式是将有类似性质的类组成一组,放在一个工厂中,这样可以十分有效的减少工厂类的数量,同时对于上层用户而言,也无需创建特别多的工厂来创建所需的对象
下面的代码解释:一个接口IEqiupable代表可穿戴的接口,然后由Weapon和Armor两个大类分别继承
接下来再细分两个大类,剑与弓,重甲与轻甲
创建IFactory工厂类接口,工厂能够创建Weapon和Armor两种物品
MeleeFactory近战工厂生产的是剑和重甲
RemoteFactory远程工厂生产的是弓和轻甲
#include <iostream>
using namespace std;
namespace AbstractFactory
{
class IEqiupable
{
public:
virtual void Show() = 0;
virtual ~IEqiupable() {};
};
class Weapon : public IEqiupable
{
public:
virtual void Show() override
{
cout << "武器:" << GetName() << "\t";
};
protected:
virtual string GetName() = 0;
};
class Sword : public Weapon
{
virtual string GetName() override
{
return "剑";
}
};
class Bow : public Weapon
{
virtual string GetName() override
{
return "弓";
}
};
class Armor : public IEqiupable
{
public:
virtual void Show() override
{
cout << "防具:" << GetName();
};
protected:
virtual string GetName() = 0;
};
class LightArmor : public Armor
{
virtual string GetName() override
{
return "轻甲";
}
};
class HeavyArmor : public Armor
{
virtual string GetName() override
{
return "重甲";
}
};
class IFactory
{
public:
virtual Weapon* CreateWeapon() = 0;
virtual Armor* CreateArmor() = 0;
};
class MeleeFactory : public IFactory
{
public:
virtual Weapon* CreateWeapon() override
{
return new Sword();
}
virtual Armor* CreateArmor() override
{
return new HeavyArmor();
}
};
class RemoteFactory : public IFactory
{
public:
virtual Weapon* CreateWeapon() override
{
return new Bow();
}
virtual Armor* CreateArmor() override
{
return new LightArmor();
}
};
}
int main()
{
//抽象工厂模式
{
using namespace AbstractFactory;
MeleeFactory meleeFacotory;
Weapon* weapon = meleeFacotory.CreateWeapon();
Armor* armor = meleeFacotory.CreateArmor();
weapon->Show();
armor->Show();
cout << endl;
delete weapon;
delete armor;
RemoteFactory remoteFactory;
weapon = remoteFactory.CreateWeapon();
armor = remoteFactory.CreateArmor();
weapon->Show();
armor->Show();
}
}