抽象工厂:
提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
适用性
- 一个系统要独立于它的产品的创建、组合和表示时。
- 一个系统要由多个产品系列中的一个来配置时。
- 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
- 当你提供一个产品类库，而只想显示它们的接口而不是实现时。
结构
AbstractFactory - 声明一个创建抽象产品对象的操作接口。
ConcreteFactory - 实现创建具体产品对象的操作。
AbstractProduct - 为一类产品对象声明一个接口
ConcreteProduct - 定义一个将被相应的具体工厂创建的产品对象。实现AbstractProduct接口。
Client - 仅使用由AbstractFactory和AbstractProduct类声明的接口。
协作：
通常在运行时创建一个ConcreteFactory类的实例。这一具体的工厂创建类具有特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。
AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。
示例代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
| #include <iostream>
class AbstractProductA{};
class ProductA1 : public AbstractProductA
{
public:
ProductA1() : AbstractProductA()
{
std::cout<<"I'm ProductA1."<<std::endl;
}
};
class ProductA2 : public AbstractProductA
{
public:
ProductA2() : AbstractProductA()
{
std::cout<<"I'm ProductA2."<<std::endl;
}
};
class AbstractProductB{};
class ProductB1 : public AbstractProductB
{
public:
ProductB1() : AbstractProductB()
{
std::cout<<"I'm ProductB1."<<std::endl;
}
};
class ProductB2 : public AbstractProductB
{
public:
ProductB2() : AbstractProductB()
{
std::cout<<"I'm ProductB2."<<std::endl;
}
};
class AbstractFactory
{
public:
virtual AbstractProductA* create_product_A() = 0;
virtual AbstractProductB* create_product_B() = 0;
};
class ConcreteFactory1 : public AbstractFactory
{
public:
virtual AbstractProductA* create_product_A()
{
return new ProductA1();
}
virtual AbstractProductB* create_product_B()
{
return new ProductB1();
}
};
class ConcreteFactory2 : public AbstractFactory
{
public:
virtual AbstractProductA* create_product_A()
{
return new ProductA2();
}
virtual AbstractProductB* create_product_B()
{
return new ProductB2();
}
};
class Client
{
public:
Client()
{
m_factory = NULL;
m_productA = NULL;
m_productB = NULL;
}
~Client() {clear();}
public:
void clear()
{
if (m_factory) delete m_factory;
m_factory = NULL;
if (m_productA) delete m_productA;
m_productA = NULL;
if(m_productB) delete m_productB;
m_productB = NULL;
}
void test1()
{
clear();
m_factory = new ConcreteFactory1();
m_productA = m_factory->create_product_A();
m_productB = m_factory->create_product_B();
}
void test2()
{
clear();
m_factory = new ConcreteFactory2();
m_productA = m_factory->create_product_A();
m_productB = m_factory->create_product_B();
}
public:
AbstractFactory* m_factory;
AbstractProductA* m_productA;
AbstractProductB* m_productB;
};
int main()
{
Client c;
c.test1();
c.test2();
system("Pause");
}
|
相关模式
- AbstractFactory类通常用Factory Method实现，也可以用Prototype实现。
- 一个具体的工厂通常是一个Singleton。
[1] 设计模式：可复用面向对象软件的基础
[2] Head First 设计模式