5Factory Method工厂方法模式.docx

5Factory Method工厂方法模式.docx

《5Factory Method工厂方法模式.docx》由会员分享，可在线阅读，更多相关《5Factory Method工厂方法模式.docx（9页珍藏版）》请在冰点文库上搜索。

5FactoryMethod工厂方法模式

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。

核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

这个例子更详细的内容及说明可以参考原作者博客：

。

贴代码了。

5.1.解释

main（），女娲

IHuman，产品接口

CYellowHuman，产品之一

CWhiteHuman，产品之二

CBlackHuman，产品之三

IHumanFactory，工厂接口

CYellowHumanFactory，工厂之一

CWhiteHumanFactory，工厂之二

CBlackHumanFactory，工厂之三

看代码：

//IHuman.h

#pragmaonce

classIHuman

{

public:

   IHuman（void）

   {

   }

   virtual~IHuman（void）

   {

   }

   virtualvoidLaugh（）=0;

   virtualvoidCry（）=0;

   virtualvoidTalk（）=0;

};

//YellowHuman.h

#pragmaonce

#include"ihuman.h"

classCYellowHuman:

   publicIHuman

{

public:

   CYellowHuman（void）;

   ~CYellowHuman（void）;

   voidLaugh（）;

   voidCry（）;

   voidTalk（）;

};

//YellowHuman.cpp

#include"StdAfx.h"

#include"YellowHuman.h"

#include

usingstd:

:

cout;

usingstd:

:

endl;

CYellowHuman:

:

CYellowHuman（void）

{

}

CYellowHuman:

:

~CYellowHuman（void）

{

}

voidCYellowHuman:

:

Cry（）

{

   cout<<"黄色人种会哭"<

}

voidCYellowHuman:

:

Laugh（）

{

   cout<<"黄色人种会大笑，幸福呀！

"<

}

voidCYellowHuman:

:

Talk（）

{

   cout<<"黄色人种会说话，一般说的都是双字节"<

}

//WhiteHuman.h

#pragmaonce

#include"ihuman.h"

classCWhiteHuman:

   publicIHuman

{

public:

   CWhiteHuman（void）;

   ~CWhiteHuman（void）;

   voidLaugh（）;

   voidCry（）;

   voidTalk（）;

};

//WhiteHuman.cpp

#include"StdAfx.h"

#include"WhiteHuman.h"

#include

usingstd:

:

cout;

usingstd:

:

endl;

CWhiteHuman:

:

CWhiteHuman（void）

{

}

CWhiteHuman:

:

~CWhiteHuman（void）

{

}

voidCWhiteHuman:

:

Cry（）

{

   cout<<"白色人种会哭"<

}

voidCWhiteHuman:

:

Laugh（）

{

   cout<<"白色人种会大笑，侵略的笑声"<

}

voidCWhiteHuman:

:

Talk（）

{

   cout<<"白色人种会说话，一般都是单字节"<

}

//BlackHuman.h

#pragmaonce

#include"ihuman.h"

classCBlackHuman:

   publicIHuman

{

public:

   CBlackHuman（void）;

   ~CBlackHuman（void）;

   voidLaugh（）;

   voidCry（）;

   voidTalk（）;

};

//BlackHuman.cpp

#include"StdAfx.h"

#include"BlackHuman.h"

#include

usingstd:

:

cout;

usingstd:

:

endl;

CBlackHuman:

:

CBlackHuman（void）

{

}

CBlackHuman:

:

~CBlackHuman（void）

{

}

voidCBlackHuman:

:

Cry（）

{

   cout<<"黑人会哭"<

}

voidCBlackHuman:

:

Laugh（）

{

   cout<<"黑人会笑"<

}

voidCBlackHuman:

:

Talk（）

{

   cout<<"黑人可以说话，一般人听不懂"<

}

//IHumanFactory.h

#pragmaonce

#include"IHuman.h"

classIHumanFactory

{

public:

   IHumanFactory（void）

   {

   }

   virtual~IHumanFactory（void）

   {

   }

   virtualIHuman*CreateHuman（）=0;

};

//YellowHuman.h

#pragmaonce

#include"ihumanfactory.h"

classCYellowHumanFactory:

   publicIHumanFactory

{

public:

   CYellowHumanFactory（void）;

   ~CYellowHumanFactory（void）;

   virtualIHuman*CreateHuman（void）;

};

//YellowHumanFactory.cpp

#include"StdAfx.h"

#include"YellowHumanFactory.h"

#include"YellowHuman.h"

CYellowHumanFactory:

:

CYellowHumanFactory（void）

{

}

CYellowHumanFactory:

:

~CYellowHumanFactory（void）

{

}

IHuman*CYellowHumanFactory:

:

CreateHuman（void）

{

   returnnewCYellowHuman（）;

}

//WhiteHuman.h

#pragmaonce

#include"ihumanfactory.h"

classCWhiteHumanFactory:

   publicIHumanFactory

{

public:

   CWhiteHumanFactory（void）;

   ~CWhiteHumanFactory（void）;

   virtualIHuman*CreateHuman（void）;

};

//WhiteHumanFactory.cpp

#include"StdAfx.h"

#include"WhiteHumanFactory.h"

#include"WhiteHuman.h"

CWhiteHumanFactory:

:

CWhiteHumanFactory（void）

{

}

CWhiteHumanFactory:

:

~CWhiteHumanFactory（void）

{

}

IHuman*CWhiteHumanFactory:

:

CreateHuman（void）

{

   returnnewCWhiteHuman（）;

}

//BlackHuman.h

#pragmaonce

#include"ihumanfactory.h"

classCBlackHumanFactory:

   publicIHumanFactory

{

public:

   CBlackHumanFactory（void）;

   ~CBlackHumanFactory（void）;

   virtualIHuman*CreateHuman（）;

};

//BlackHumanFactory.cpp

#include"StdAfx.h"

#include"BlackHumanFactory.h"

#include"BlackHuman.h"

CBlackHumanFactory:

:

CBlackHumanFactory（void）

{

}

CBlackHumanFactory:

:

~CBlackHumanFactory（void）

{

}

IHuman*CBlackHumanFactory:

:

CreateHuman（）

{

   returnnewCBlackHuman（）;

}

//FactoryMethod.cpp

//FactoryMethod.cpp:

定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include"IHuman.h"

#include"YellowHuman.h"

#include"WhiteHuman.h"

#include"BlackHuman.h"

#include"SimpleHumanFactory.h"

#include"StandardHumanFactory.h"

#include"IHumanFactory.h"

#include"YellowHumanFactory.h"

#include"WhiteHumanFactory.h"

#include"BlackHumanFactory.h"

#include

usingstd:

:

cout;

usingstd:

:

endl;

usingstd:

:

string;

voidDoFactoryMethod1（）

{

   cout<<"----------第一批人是这样的：

黄种人工厂来生产黄种人"<

   IHumanFactory*pHumanFactory=newCYellowHumanFactory（）;

   IHuman*pHuman=pHumanFactory->CreateHuman（）;

   pHuman->Cry（）;

   pHuman->Laugh（）;

   pHuman->Talk（）;

   deletepHuman;

   deletepHumanFactory;

}

voidDoFactoryMethod2（）

{

   cout<<"----------第二批人是这样的：

白种人工厂来生产白种人"<

   IHumanFactory*pHumanFactory=newCWhiteHumanFactory（）;

   IHuman*pHuman=pHumanFactory->CreateHuman（）;

   pHuman->Cry（）;

   pHuman->Laugh（）;

   pHuman->Talk（）;

   deletepHuman;

   deletepHumanFactory;

}

voidDoFactoryMethod3（）

{

   cout<<"----------第一批人是这样的：

黑种人工厂来生产黑种人"<

   IHumanFactory*pHumanFactory=newCBlackHumanFactory（）;

   IHuman*pHuman=pHumanFactory->CreateHuman（）;

   pHuman->Cry（）;

   pHuman->Laugh（）;

   pHuman->Talk（）;

   deletepHuman;

   deletepHumanFactory;

}

int_tmain（intargc,_TCHAR*argv[]）

{

   //工厂方法

   cout<<"----------工厂方法：

"<

   DoFactoryMethod1（）;

   DoFactoryMethod2（）;

   DoFactoryMethod3（）;

   _CrtSetDbgFlag（_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF）;

   _CrtDumpMemoryLeaks（）;

   return0;

}

工厂方法属于创建型模式，适合于产品不太多的情况。

产品如果很多，则需要用抽象工厂来实现。