抽象工厂模式是对象创建形模式的一种。抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。总的来说就是当发现需要创建一系列的对象,而此时发现耦合又高,为了以后的可扩展性,可以使用该模式。该模式的UML图如下:
意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们的具体类
适用性:1 一个系统要独立于它的产品的创建,组合和表示时;
2 一个系统要由多个产品系列中的一个配置时;
3 当你提供一个产品类时,而只是想表示他们的接口而不是实现时;
协作 :通常在运行的时刻创建一个ConcreateFactory的实列,为创建不同的产品,客户应使用不同的具体工厂。AbstractoryFactory把创建产品对象的任务推迟到他的子类
优缺点 优点
1 分离了具体的类,客户与类的实现分离,产品的类名也不出现的客户的代码当中
2 易与交换产品系列
3 有利于产品的一致性
缺点
1 难于支持新的 产品 ,因为抽象工厂类的接口已经写好了,要实现另外的产品必须要修改抽象工厂的类的接
口和增加新的产品类
下面是以假设生产人种为例,三种肤色的人种,性别有男女 例子:
首先是UML图:
下面是实现,首先是人种的接口类Human
#pragma once
//人类接口
class Human
{
public:
//相应的人种颜色
virtual void getColor();
//说话
virtual void talk();
//性别
virtual void getSex();
private:
};
#include "Human.h"
void Human::getColor()
{
}
void Human::talk()
{
}
void Human::getSex()
{
}
//具体的黑色人种
//AbstractBlackHuman.h
#pragma once
#include "Human.h"
#include <iostream>
class AbstractBlackHuman : public Human
{
public:
AbstractBlackHuman();
~AbstractBlackHuman();
void getColor();
void talk();
private:
};
#include "AbstractBlackHuman.h"
using namespace std;
AbstractBlackHuman::AbstractBlackHuman()
{
}
AbstractBlackHuman::~AbstractBlackHuman()
{
}
void AbstractBlackHuman::getColor()
{
cout << "黑色人种的皮肤颜色是黑色的" <<endl;
}
void AbstractBlackHuman::talk()
{
cout << "黑色人种一般说的是多字节" << endl;
}
//黑色女性
#pragma once
#include "AbstractBlackHuman.h"
#include <iostream>
class FemaleBlackHuman : public AbstractBlackHuman
{
public:
FemaleBlackHuman();
~FemaleBlackHuman();
void getSex();
private:
};
#include "FemaleBlackHuman.h"
using namespace std;
FemaleBlackHuman::FemaleBlackHuman()
{
}
FemaleBlackHuman::~FemaleBlackHuman()
{
}
void FemaleBlackHuman::getSex()
{
cout << "黑色女性" << endl;
}
//黑色男性
#pragma once
#include "AbstractBlackHuman.h"
#include <iostream>
class MaleBlackHuman : public AbstractBlackHuman
{
public:
MaleBlackHuman();
~MaleBlackHuman();
void getSex();
private:
};
#include "MaleBlackHuman.h"
using namespace std;
MaleBlackHuman::MaleBlackHuman()
{
}
MaleBlackHuman::~MaleBlackHuman()
{
}
void MaleBlackHuman::getSex()
{
cout << "黑色男性" << endl;
}
//白色人种
//AbstractWhiteHuman.h
#pragma once
#include "Human.h"
#include <iostream>
class AbstractWhiteHuman : public Human
{
public:
AbstractWhiteHuman();
~AbstractWhiteHuman();
void getColor();
void talk();
private:
};
#include "AbstractWhiteHuman.h"
using namespace std;
AbstractWhiteHuman::AbstractWhiteHuman()
{
}
AbstractWhiteHuman::~AbstractWhiteHuman()
{
}
void AbstractWhiteHuman::getColor()
{
cout << "白色人种的皮肤颜色是白色的" << endl;
}
void AbstractWhiteHuman::talk()
{
cout << "白色人种一般说的是单字节" << endl;
}
//白色女性
#pragma once
#include "AbstractWhiteHuman.h"
#include <iostream>
class FemaleWhiteHuman : public AbstractWhiteHuman
{
public:
FemaleWhiteHuman();
~FemaleWhiteHuman();
void getSex();
private:
};
#include "FemaleWhiteHuman.h"
using namespace std;
FemaleWhiteHuman::FemaleWhiteHuman()
{
}
FemaleWhiteHuman::~FemaleWhiteHuman()
{
}
void FemaleWhiteHuman::getSex()
{
cout << "白色女性" << endl;
}
//白色男性
#pragma once
#include "AbstractWhiteHuman.h"
#include <iostream>
class MaleWhiteHuman : public AbstractWhiteHuman
{
public:
MaleWhiteHuman();
~MaleWhiteHuman();
void getSex();
private:
};
#include "MaleWhiteHuman.h"
using namespace std;
MaleWhiteHuman::MaleWhiteHuman()
{
}
MaleWhiteHuman::~MaleWhiteHuman()
{
}
void MaleWhiteHuman::getSex()
{
cout << "白色男性" << endl;
}
//黄色人种
//AbstractYellowHuman.h
#pragma once
#include "Human.h"
#include <iostream>
class AbstractYellowHuman : public Human
{
public:
AbstractYellowHuman();
~AbstractYellowHuman();
void getColor();
void talk();
private:
};
#include "AbstractYellowHuman.h"
using namespace std;
AbstractYellowHuman::AbstractYellowHuman()
{
}
AbstractYellowHuman::~AbstractYellowHuman()
{
}
void AbstractYellowHuman::getColor()
{
cout << "黄色人种的皮肤颜色是黄色的" << endl;
}
void AbstractYellowHuman::talk()
{
cout << "黄色人种一般说的是双字节" << endl;
}
//黄色女性
#pragma once
#include "AbstractYellowHuman.h"
#include <iostream>
class FemaleYellowHuman : public AbstractYellowHuman
{
public:
FemaleYellowHuman();
~FemaleYellowHuman();
void getSex();
private:
};
#include "FemaleYellowHuman.h"
using namespace std;
FemaleYellowHuman::FemaleYellowHuman()
{
}
FemaleYellowHuman::~FemaleYellowHuman()
{
}
void FemaleYellowHuman::getSex()
{
cout << "黄色女性" << endl;
}
//黄色男性
#pragma once
#include "AbstractYellowHuman.h"
#include <iostream>
class MaleYellowHuman : public AbstractYellowHuman
{
public:
MaleYellowHuman();
~MaleYellowHuman();
void getSex();
private:
};
#include "MaleYellowHuman.h"
using namespace std;
MaleYellowHuman::MaleYellowHuman()
{
}
MaleYellowHuman::~MaleYellowHuman()
{
}
void MaleYellowHuman::getSex()
{
cout << "黄色男性" << endl;
}
以上是产品的信息类,都是继承与Human类,Human作为人类的抽象接口。接下来就是工厂类,工厂类也有一个抽象的接口HumanFactory,采用纯虚函数:
#pragma once
#include "Human.h"
class HumanFactory
{
public:
HumanFactory();
~HumanFactory();
virtual Human* createBlackHuman() = 0;
virtual Human* createWhiteHuman() = 0;
virtual Human* createYellowHuman() = 0;
private:
};
//男性工厂类,返回三种人种的男性
#pragma once
#include "HumanFactory.h"
#include "MaleBlackHuman.h"
#include "MaleWhiteHuman.h"
#include "MaleYellowHuman.h"
class MaleFactory : public HumanFactory
{
public:
MaleFactory();
~MaleFactory();
Human* createBlackHuman();
Human* createWhiteHuman();
Human* createYellowHuman();
private:
};
#include "MaleFactory.h"
MaleFactory::MaleFactory()
{
}
MaleFactory::~MaleFactory()
{
}
Human* MaleFactory::createBlackHuman()
{
return new MaleBlackHuman();
}
Human* MaleFactory::createWhiteHuman()
{
return new MaleWhiteHuman();
}
Human* MaleFactory::createYellowHuman()
{
return new MaleYellowHuman();
}
//女性产品的工厂类,返回三种人种的女性类
#pragma once
#include "HumanFactory.h"
#include "FemaleBlackHuman.h"
#include "FemaleWhiteHuman.h"
#include "FemaleYellowHuman.h"
class FemaleFactory : public HumanFactory
{
public:
FemaleFactory();
~FemaleFactory();
Human* createBlackHuman();
Human* createWhiteHuman();
Human* createYellowHuman();
private:
};
#include "FemaleFactory.h"
FemaleFactory::FemaleFactory()
{
}
FemaleFactory::~FemaleFactory()
{
}
Human* FemaleFactory::createBlackHuman()
{
return new FemaleBlackHuman();
}
Human* FemaleFactory::createWhiteHuman()
{
return new FemaleWhiteHuman();
}
Human* FemaleFactory::createYellowHuman()
{
return new FemaleYellowHuman();
}
产品类和工厂类的实现完成了,接下来就客户调用的方法了,
#include "stdafx.h"
#include "Human.h"
#include "HumanFactory.h"
#include "FemaleFactory.h"
#include "MaleFactory.h"
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
//生产女性工厂
HumanFactory* femaleFactory = new FemaleFactory();
//女性工厂生产出的黑色皮肤的女性
Human* femaleBlackHuam = femaleFactory->createBlackHuman();
femaleBlackHuam->getColor();
femaleBlackHuam->getSex();
femaleBlackHuam->talk();
//男性工厂
HumanFactory* maleFactory = new MaleFactory();
//男性工厂生产出的黑色皮肤的男性
Human* maleBlackHuame = maleFactory->createBlackHuman();
maleBlackHuame->getColor();
maleBlackHuame->getSex();
maleBlackHuame->talk();
return 0;
}
抽象工厂的学习先告一段落,以后有更好的理解的时候,回来修改。