1.简单描述
抽象工厂包含两部分:一是继承自同一个抽象类的产品类族;二是不同类型的抽象工厂。抽象工厂中可以创建该类产品所需要的元素(创建产品类的数据成员),而生产的所有元素便是抽象工厂的产物。由于抽象工厂可以生成许多元素,所以我们又可以认为,抽象工厂是封装了多个工厂方法,对于每一个元素就相当于一个工厂方法。到底是哪一种类型的元素则由具体的工厂类型决定(子类决定)。产品不再作为抽象工厂的直接输出产物,而是使用工厂的输出组合而成,所以产品可以更加抽象不用再区分大类(大类由抽象工厂决定)。
2.类图
。。。。。。。。
待补
3.实例程序
3.1 元素定义
#ifndef Ingredient_H
#define Ingredient_H
#include <string>
#include <iostream>
class IngredientA
{
public:
virtual void printIngredientName() = 0;
};
class IngredientA1: public IngredientA
{
void printIngredientName()
{
std::cout<<"IngredientA1"<<std::endl;
}
};
class IngredientA2: public IngredientA
{
void printIngredientName()
{
std::cout<<"IngredientA2"<<std::endl;
}
};
class IngredientB
{
public:
virtual void printIngredientName() = 0;
};
class IngredientB1: public IngredientB
{
void printIngredientName()
{
std::cout<<"IngredientB1"<<std::endl;
}
};
class IngredientB2: public IngredientB
{
void printIngredientName()
{
std::cout<<"IngredientB2"<<std::endl;
}
};
#endif
3.2 产品定义
// product.h
#ifndef Product_H
#define Product_H
#include "Ingredient.h"
class AbstractFactory;
class Product
{
public:
Product(){};
virtual ~Product(){};
virtual void printProductName() = 0;
};
class ProductA: public Product
{
public:
ProductA(const AbstractFactory& factory);
virtual ~ProductA(){};
virtual void printProductName();
private:
IngredientA* m_pIA;
// IngredientB* m_pIB;
};
class ProductB: public Product
{
public:
ProductB(const AbstractFactory& factory);
virtual ~ProductB(){};
virtual void printProductName();
private:
IngredientA* m_pIA;
IngredientB* m_pIB;
};
#endif
// product.cpp
#include "stdafx.h"
#include <iostream>
#include "Product.h"
#include "AbstractFactory.h"
using namespace std;
ProductA::ProductA(const AbstractFactory& factory)
{
m_pIA = factory.createIngredientA();
}
void ProductA::printProductName()
{
cout<<"ProductA->";
if (NULL != m_pIA)
{
m_pIA->printIngredientName();
}
}
ProductB::ProductB(const AbstractFactory& factory)
{
m_pIA = factory.createIngredientA();
m_pIB = factory.createIngredientB();
}
void ProductB::printProductName()
{
cout<<"ProductB->";
if (NULL != m_pIB)
{
m_pIB->printIngredientName();
}
cout<<"ProductB->";
if (NULL != m_pIA)
{
m_pIA->printIngredientName();
}
}
3.3 工厂定义
// factory,h
#ifndef AbstractFactory_H
#define AbstractFactory_H
#include "Ingredient.h"
class AbstractFactory
{
public:
virtual IngredientA* createIngredientA() const = 0;
virtual IngredientB* createIngredientB() const = 0;
};
class AbstractFactoryA: public AbstractFactory
{
public:
AbstractFactoryA(){};
~AbstractFactoryA(){};
virtual IngredientA* createIngredientA() const;
virtual IngredientB* createIngredientB() const;
};
class AbstractFactoryB: public AbstractFactory
{
public:
AbstractFactoryB(){};
~AbstractFactoryB(){};
virtual IngredientA* createIngredientA() const;
virtual IngredientB* createIngredientB() const;
};
#endif
// factory.cpp
#include "stdafx.h"
#include "AbstractFactory.h"
IngredientA* AbstractFactoryA::createIngredientA() const
{
return new IngredientA1();
}
IngredientB* AbstractFactoryA::createIngredientB() const
{
return new IngredientB1();
}
IngredientA* AbstractFactoryB::createIngredientA() const
{
return new IngredientA2();
}
IngredientB* AbstractFactoryB::createIngredientB() const
{
return new IngredientB2();
}
3.4 测试程序
// test.cpp
#include <iostream>
#include "AbstractFactory.h"
#include "Product.h"
using namespace std;
int main(int argc, char const *argv[])
{
/* code */
AbstractFactoryA factoryA;
AbstractFactory& factory1 = factoryA;
Product* produce1 = new ProductA(factory1);
if (NULL != produce1)
{
produce1->printProductName();
delete produce1;
produce1 = NULL;
}
produce1 = new ProductB(factory1);
if (NULL != produce1)
{
produce1->printProductName();
delete produce1;
produce1 = NULL;
}
AbstractFactoryB factoryB;
factory1 = factoryB;
produce1 = new ProductA(factory1);
if (NULL != produce1)
{
produce1->printProductName();
delete produce1;
produce1 = NULL;
}
produce1 = new ProductB(factory1);
if (NULL != produce1)
{
produce1->printProductName();
delete produce1;
produce1 = NULL;
}
return 0;
}
4.扩展分析
4.1 产品扩展
1.对于普通工厂模式,新增产品需要扩充产品子类,在一个或多个工厂类中加入新扩充产品的创建。
2.对于抽象工厂模式,新增产品只需要扩充产品子类,新产品可有老元素组合而成,工厂类不用变化,也不会加减。
4.2 产品元素扩展
1.对于普通工厂模式,需要修改所有加入新元素的类。
2.对于抽象工厂模式,需要修改所有加入新元素的类,同时修改需要生成该元素的工厂。