设计模式解析和实现之二-Abstract Factory模式
2012-11-12 12:46
225 查看
作用:
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
UML结构图:
抽象基类:
1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现。
2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现。
接口函数:
1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分别是生产不同产品的不同的实现,由各个派生出来的抽象工厂实现之。
解析:
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂,等等。
可以举一个简单的例子来解释这个模式:比如,同样是鸡腿(ProductA)和汉堡(ProductB),它们都可以有商店出售(AbstractFactory),但是有不同的实现,有肯德基(ConcreateFactory1)和麦当劳(ConcreateFactory2)两家生产出来的不同风味的鸡腿和汉堡(也就是ProductA和ProductB的不同实现)。
而负责生产汉堡和鸡腿的就是之前提过的Factory模式了。
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现。显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用。
实现:
1)AbstractFactory.h
2)AbstractFactory.cpp
3)Main.cpp(测试代码)
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
UML结构图:
抽象基类:
1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现。
2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现。
接口函数:
1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分别是生产不同产品的不同的实现,由各个派生出来的抽象工厂实现之。
解析:
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂,等等。
可以举一个简单的例子来解释这个模式:比如,同样是鸡腿(ProductA)和汉堡(ProductB),它们都可以有商店出售(AbstractFactory),但是有不同的实现,有肯德基(ConcreateFactory1)和麦当劳(ConcreateFactory2)两家生产出来的不同风味的鸡腿和汉堡(也就是ProductA和ProductB的不同实现)。
而负责生产汉堡和鸡腿的就是之前提过的Factory模式了。
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现。显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用。
实现:
1)AbstractFactory.h
#ifndef ABSTRACTFACTORY_H #define ABSTRACTFACTORY_H // 抽象基类AbstractProductA,代表产品A的抽象 class AbstractProductA { public: AbstractProductA() {} virtual ~AbstractProductA(){}; }; // 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现 class ConcreateProductA1 : public AbstractProductA { public: ConcreateProductA1(); virtual ~ConcreateProductA1(); }; // 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现 class ConcreateProductA2 : public AbstractProductA { public: ConcreateProductA2(); virtual ~ConcreateProductA2(); }; // 抽象基类AbstractProductB,代表产品B的抽象 class AbstractProductB { public: AbstractProductB() {} virtual ~AbstractProductB(){}; }; // 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现 class ConcreateProductB1 : public AbstractProductB { public: ConcreateProductB1(); virtual ~ConcreateProductB1(); }; // 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现 class ConcreateProductB2 : public AbstractProductB { public: ConcreateProductB2(); virtual ~ConcreateProductB2(); }; // 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B class AbstractFactory { public: AbstractFactory(){} virtual ~AbstractFactory(){} virtual AbstractProductA* CreateProductA() = 0; virtual AbstractProductB* CreateProductB() = 0; }; // 派生类ConcreateFactory1,继承自AbstractFactory // 生产产品A和产品B的第一种实现 class ConcreateFactory1 : public AbstractFactory { public: ConcreateFactory1(); virtual ~ConcreateFactory1(); virtual AbstractProductA* CreateProductA(); virtual AbstractProductB* CreateProductB(); }; // 派生类ConcreateFactory2,继承自AbstractFactory // 生产产品A和产品B的第二种实现 class ConcreateFactory2 : public AbstractFactory { public: ConcreateFactory2(); virtual ~ConcreateFactory2(); virtual AbstractProductA* CreateProductA(); virtual AbstractProductB* CreateProductB(); }; #endif |
#include <iostream> #include "AbstractFactory.h" ConcreateProductA1::ConcreateProductA1() { std::cout << "construction of ConcreateProductA1n"; } ConcreateProductA1::~ConcreateProductA1() { std::cout << "destruction of ConcreateProductA1n"; } ConcreateProductA2::ConcreateProductA2() { std::cout << "construction of ConcreateProductA2n"; } ConcreateProductA2::~ConcreateProductA2() { std::cout << "destruction of ConcreateProductA2n"; } ConcreateProductB1::ConcreateProductB1() { std::cout << "construction of ConcreateProductB1n"; } ConcreateProductB1::~ConcreateProductB1() { std::cout << "destruction of ConcreateProductB1n"; } ConcreateProductB2::ConcreateProductB2() { std::cout << "construction of ConcreateProductB2n"; } ConcreateProductB2::~ConcreateProductB2() { std::cout << "destruction of ConcreateProductB2n"; } ConcreateFactory1::ConcreateFactory1() { std::cout << "construction of ConcreateFactory1n"; } ConcreateFactory1::~ConcreateFactory1() { std::cout << "destruction of ConcreateFactory1n"; } AbstractProductA* ConcreateFactory1::CreateProductA() { return new ConcreateProductA1(); } AbstractProductB* ConcreateFactory1::CreateProductB() { return new ConcreateProductB1(); } ConcreateFactory2::ConcreateFactory2() { std::cout << "construction of ConcreateFactory2n"; } ConcreateFactory2::~ConcreateFactory2() { std::cout << "destruction of ConcreateFactory2n"; } AbstractProductA* ConcreateFactory2::CreateProductA() { return new ConcreateProductA2(); } AbstractProductB* ConcreateFactory2::CreateProductB() { return new ConcreateProductB2(); } |
#include "AbstractFactory.h" #include <stdlib.h> int main() { // 生产产品A的第一种实现 ConcreateFactory1 *pFactory1 = new ConcreateFactory1; AbstractProductA *pProductA = pFactory1->CreateProductA(); // 生产产品B的第二种实现 ConcreateFactory2 *pFactory2 = new ConcreateFactory2; AbstractProductB *pProductB = pFactory2->CreateProductB(); delete pFactory1; delete pProductA; delete pFactory2; delete pProductB; system("pause"); return 0; } |
相关文章推荐
- 常见设计模式的解析和实现(C++)之二-Abstract Factory模式
- 常见设计模式的解析和实现(C++)之二-Abstract Factory模式
- 常见设计模式的解析和实现(C++)之二-Abstract Factory模式
- 《设计模式--基于C#的工程化实现及扩展》 Security Design Pattern 系列 3 检查点模式(Check Point)
- 研磨设计模式解析及python代码实现——(二)外观模式(Facade)
- 设计模式的解析和实现(C++)之五-Singleton模式
- 常见设计模式的解析和实现(C++)之三-Builder模式
- Android源码设计模式解析与实战之二单例模式
- 常见设计模式的解析和实现(C++)之七-Bridge模式
- 设计模式的解析和实现(C++)之十七-State模式
- ThinkPHP-路由解析的实现和(开发调试模式的实现)
- 设计模式C++实现(8)——代理模式
- 设计模式C++实现(5)——原型模式、模板方法模式
- 设计模式C++实现(2)——策略模式
- 设计模式(Design Pattern) - 创建型模式(Creational Pattern) - 抽象工厂模式(Abstract Factory) - Java实现
- 设计模式C++实现(13)——中介者模式(Mediator)
- 常见设计模式的解析和实现(C++)之十七-State模式
- 常见设计模式的解析和实现(C++)之五-Singleton模式
- 设计模式(14) 命令模式(Command)C++实现
- 设计模式C++实现(7)——外观模式、组合模式