抽象工厂模式提供接口用于创建相关对象, 而不需要明确指定具体类
客户从具体的产品中被解耦
抽象工厂使用对象组合, 对象的创建被是现在工厂接口所暴露的方法中
抽象工厂创建相关的对象家族, 而不需要依赖它们的具体类
#ifndef AbstractFactory_h
#define AbstractFactory_h
class AbstractProductA
{
public:
virtual void method() = 0;
};
class ProductA1 : public AbstractProductA
{
public:
virtual void method()
{
printf("AbstractProductA ProductA1 method.\n");
}
};
class ProductA2 : public AbstractProductA
{
public:
virtual void method()
{
printf("AbstractProductA ProductA2 method.\n");
}
};
class AbstractProductB
{
public:
virtual void method() = 0;
};
class ProductB1 : public AbstractProductB
{
public:
virtual void method()
{
printf("AbstractProductB ProductB1 method.\n");
}
};
class ProductB2 : public AbstractProductB
{
public:
virtual void method()
{
printf("AbstractProductB ProductB2 method.\n");
}
};
class AbstractFactory
{
public:
virtual AbstractProductA *createProductA() = 0;
virtual AbstractProductB *createProductB() = 0;
};
class Factory1 : public AbstractFactory
{
public:
virtual AbstractProductA *createProductA()
{
return new ProductA1();
}
virtual AbstractProductB *createProductB()
{
return new ProductB1();
}
};
class Factory2 : public AbstractFactory
{
public:
virtual AbstractProductA *createProductA()
{
return new ProductA2();
}
virtual AbstractProductB *createProductB()
{
return new ProductB2();
}
};
#endif
测试
#include <iostream>
#include "AbstractFactory.h"
int main(int argc, char **argv)
{
Factory1 factory1;
Factory2 factory2;
AbstractProductA *productA1 = factory1.createProductA();
AbstractProductA *productA2 = factory2.createProductA();
AbstractProductB *productB1 = factory1.createProductB();
AbstractProductB *productB2 = factory2.createProductB();
productA1->method();
productA2->method();
productB1->method();
productB2->method();
return 0;
}