抽象工厂模式属于创建型的设计模式,抽象工厂模式针对的是多个产品等级结构,而工厂方法模式是针对单个产品等级结构的。理解抽象工厂模式需要理解产品族和产品等级这两个概念。 产品族:是指位于不同产品等级结构中,功能相关联的产品组成的家族。比如AMD的主板、芯片组、CPU组成一个家族,Intel的主板、芯片组、CPU组成一个家族。 产品等级:由相同的结构的产品组成,比如主板、芯片组和CPU就构成了3个产品等级。 优点:(1)分离接口和实现;客户端使用抽象工厂来创建需要的对象,而客户端根本就不知道具体的实现是谁,客户端只是面向产品的接口编程而已。也就是说,客户端从具体的产品实现中解耦。(2)使切换和添加产品族变得容易;因为一个具体的工厂实现代表的是一个产品族,比如上面例子的从Intel系列到AMD系列只需要切换一下具体工厂。我也可以再添加一个新的装机方案,一个新的产品族,都是很方便的。 缺点:不容易扩展新的产品等级,因为需要修改抽象工厂的接口。
此处以Cpu和MainBoard作为两个产品等级,以Intel和Amd作为产品族来说明抽象工厂模式。
文件构成: —include ——Cpu.h ——AmdCpu.h ——IntelCpu.h ——MainBoard.h ——AmdMainBoard.h ——IntelMainBoard.h ——Factory.h ——AmdFactory.h ——IntelFactory.h —src ——Cpu.cpp ——AmdCpu.cpp ——IntelCpu.cpp ——MainBoard.cpp ——AmdMainBoard.cpp ——IntelMainBoard.cpp ——Factory.cpp ——AmdFactory.cpp ——IntelFactory.cpp ——main.cpp 代码如下: —include/Cpu.h
#ifndef _CPU_H_#define _CPU_H_class Cpu{public: virtual ~Cpu(); virtual void ShowCpuInformation()=0;};#endif—include/AmdCpu.h
#ifndef _AMDCPU_H_#define _AMDCPU_H_#include"Cpu.h"class AmdCpu:public Cpu{public: virtual ~AmdCpu(); virtual void ShowCpuInformation();};#endif—include/IntelCpu.h
#ifndef _INTELCPU_H_#define _INTELCPU_H_#include"Cpu.h"class IntelCpu:public Cpu{public: virtual ~IntelCpu(); virtual void ShowCpuInformation();};#endif—include/MainBoard.h
#ifndef _MAINBOARD_H_#define _MAINBOARD_H_class MainBoard{public: virtual ~MainBoard(); virtual void ShowMainBoardInformation()=0;};#endif—include/AmdMainBoard.h
#ifndef _AMDMAINBOARD_H_#define _AMDMAINBOARD_H_#include"MainBoard.h"class AmdMainBoard:public MainBoard{public: virtual ~AmdMainBoard(); virtual void ShowMainBoardInformation();};#endif—include/IntelMainBoard.h
#ifndef _INTELMAINBOARD_H_ #define _INTELMAINBOARD_H_#include"MainBoard.h"class IntelMainBoard:public MainBoard{public: virtual ~IntelMainBoard(); virtual void ShowMainBoardInformation();};#endif—include/Factory.h
#ifndef _FACTORY_H_#define _FACTORY_H_#include"Cpu.h"#include"MainBoard.h"class Factory{public: virtual ~Factory(); virtual Cpu* CreateCpu()=0; virtual MainBoard* CreateMainBoard()=0;};#endif—include/AmdFactory.h
#ifndef _AMDFACTORY_H_#define _AMDFACTORY_H_#include"Factory.h"class AmdFactory:public Factory{public: virtual ~AmdFactory(); virtual Cpu* CreateCpu(); virtual MainBoard* CreateMainBoard();};#endif—include/IntelFactory.h
#ifndef _INTELFACTORY_H_#define _INTELFACTORY_H_#include"Factory.h"class IntelFactory:public Factory{public: virtual ~IntelFactory(); virtual Cpu* CreateCpu(); virtual MainBoard* CreateMainBoard();};#endif—src/Cpu.cpp
#include"Cpu.h"Cpu::~Cpu(){ ;}—src/AmdCpu.cpp
#include<iostream>#include"AmdCpu.h"using namespace std;AmdCpu::~AmdCpu(){ ;}void AmdCpu::ShowCpuInformation(){ cout<<"This is an AmdCpu."<<endl;}—src/IntelCpu.cpp
#include<iostream>#include "IntelCpu.h"using namespace std;IntelCpu::~IntelCpu(){ ;}void IntelCpu::ShowCpuInformation(){ cout<<"This is an IntelCpu."<<endl;}—src/MainBoard.cpp
#include"MainBoard.h"MainBoard::~MainBoard(){ ;}—src/AmdMainBoard.cpp
#include<iostream>#include"AmdMainBoard.h"using namespace std;AmdMainBoard::~AmdMainBoard(){ ;}void AmdMainBoard::ShowMainBoardInformation(){ cout<<"This is an AmdMainBoard."<<endl;}—src/IntelMainBoard.cpp
#include<iostream>#include"IntelMainBoard.h"using namespace std;IntelMainBoard::~IntelMainBoard(){ ;}void IntelMainBoard::ShowMainBoardInformation(){ cout<<"This is an IntelMainBoard."<<endl;}—src/Factory.cpp
#include"Factory.h"Factory::~Factory(){ ;}—src/AmdFactory.cpp
#include"AmdFactory.h"#include"AmdCpu.h"#include"AmdMainBoard.h"AmdFactory::~AmdFactory(){ ;}Cpu* AmdFactory::CreateCpu(){ return new AmdCpu();}MainBoard* AmdFactory::CreateMainBoard(){ return new AmdMainBoard();}—src/IntelFactory.cpp
#include"IntelFactory.h"#include"IntelCpu.h"#include"IntelMainBoard.h"IntelFactory::~IntelFactory(){ ;}Cpu* IntelFactory::CreateCpu(){ return new IntelCpu();}MainBoard* IntelFactory::CreateMainBoard(){ return new IntelMainBoard();}—src/main.cpp
#include<iostream>#include"IntelFactory.h"#include"AmdFactory.h"#include"IntelCpu.h"#include"IntelMainBoard.h"#include"AmdCpu.h"#include"AmdMainBoard.h"using namespace std;int main(){ Factory* intelFac = new IntelFactory(); Factory* amdFac = new AmdFactory(); Cpu* intelCpu = intelFac->CreateCpu(); Cpu* amdCpu = amdFac->CreateCpu(); MainBoard* intelMainBoard = intelFac->CreateMainBoard(); MainBoard* amdMainBoard = amdFac->CreateMainBoard(); intelCpu->ShowCpuInformation(); amdCpu->ShowCpuInformation(); intelMainBoard->ShowMainBoardInformation(); amdMainBoard->ShowMainBoardInformation(); delete amdMainBoard; delete amdCpu; delete amdFac; delete intelMainBoard; delete intelCpu; delete intelFac; return 0;}文件构成: —Cpu.py —MainBoard.py —Factory.py 代码如下: —Cpu.py
# -*- coding:utf-8 -*-class Cpu: def ShowCpuInformation(self): passclass IntelCpu(Cpu): def ShowCpuInformation(self): PRint "This is an IntelCpu."class AmdCpu(Cpu): def ShowCpuInformation(self): print "This is an AmdCpu."—MainBoard.py
# -*- coding:utf-8 -*-class MainBoard: def ShowMainBoard(self): passclass IntelMainBoard(MainBoard): def ShowMainBoard(self): print "This is an IntelMainBoard."class AmdMainBoard(MainBoard): def ShowMainBoard(self): print "This is an AmdMainBoard."—Factory.py
# -*- coding:utf-8 -*-from Cpu import *from MainBoard import *class Factory: def CreateCpu(self): pass def CreateMainBoard(self): passclass IntelFactory(Factory): def CreateCpu(self): return IntelCpu() def CreateMainBoard(self): return IntelMainBoard()class AmdFactory(Factory): def CreateCpu(self): return AmdCpu() def CreateMainBoard(self): return AmdMainBoard()if "__main__" == __name__: intelFac = IntelFactory() amdFac = AmdFactory() intelFac.CreateCpu().ShowCpuInformation() amdFac.CreateCpu().ShowCpuInformation() intelFac.CreateMainBoard().ShowMainBoard() amdFac.CreateMainBoard().ShowMainBoard()新闻热点
疑难解答