定义：
用于提供一个不需要指定具体的类就能去创建一系列相互关联的对象的接口。
UML图：
参与者：
这种设计模式的参与者：
1、抽象工厂（AbstractFactory）：声明一个创建抽象产品操作的接口
2、具体工厂（ConcreteFactory）：实现创建具体产品的操作方法
3、抽象产品（AbstractProduct）：为产品类型对象声明的接口
4、产品（Product）：1、实现AbstractProduct；2、定义将由ConcreteFactory创建的产品对象。
5、客户端（Client ）：使用AbstractFactory和AbstractProduct类声明的接口
示例：
下面代码使用抽象工厂模式创建同一个层次的对象。对象创建过程被抽象出来了，在Client代码中没有使用对象的类。
1 class Program
2 {
3 /// <summary>
4
5 /// Entry point into console application.
6
7 /// </summary>
8
9 public static void Main()
10 {
11
12 // Abstract factory #1
13
14 AbstractFactory factory1 = new ConcreteFactory1();
15
16 Client client1 = new Client(factory1);
17
18 client1.Run();
19
20
21
22 // Abstract factory #2
23
24 AbstractFactory factory2 = new ConcreteFactory2();
25
26 Client client2 = new Client(factory2);
27
28 client2.Run();
29
30
31
32 // Wait for user input
33
34 Console.ReadKey();
35
36 }
37
38 }
39
40
41
42 /// <summary>
43
44 /// The 'AbstractFactory' abstract class
45
46 /// </summary>
47
48 abstract class AbstractFactory
49 {
50
51 public abstract AbstractProductA CreateProductA();
52
53 public abstract AbstractProductB CreateProductB();
54
55 }
56
57
58
59
60
61 /// <summary>
62
63 /// The 'ConcreteFactory1' class
64
65 /// </summary>
66
67 class ConcreteFactory1 : AbstractFactory
68 {
69
70 public override AbstractProductA CreateProductA()
71 {
72
73 return new ProductA1();
74
75 }
76
77 public override AbstractProductB CreateProductB()
78 {
79
80 return new ProductB1();
81
82 }
83
84 }
85
86
87
88 /// <summary>
89
90 /// The 'ConcreteFactory2' class
91
92 /// </summary>
93
94 class ConcreteFactory2 : AbstractFactory
95 {
96
97 public override AbstractProductA CreateProductA()
98 {
99
100 return new ProductA2();
101
102 }
103
104 public override AbstractProductB CreateProductB()
105 {
106
107 return new ProductB2();
108
109 }
110
111 }
112
113
114
115 /// <summary>
116
117 /// The 'AbstractProductA' abstract class
118
119 /// </summary>
120
121 abstract class AbstractProductA
122 {
123
124 }
125
126
127
128 /// <summary>
129
130 /// The 'AbstractProductB' abstract class
131
132 /// </summary>
133
134 abstract class AbstractProductB
135 {
136
137 public abstract void Interact(AbstractProductA a);
138
139 }
140
141
142
143
144
145 /// <summary>
146
147 /// The 'ProductA1' class
148
149 /// </summary>
150
151 class ProductA1 : AbstractProductA
152 {
153
154 }
155
156
157
158 /// <summary>
159
160 /// The 'ProductB1' class
161
162 /// </summary>
163
164 class ProductB1 : AbstractProductB
165 {
166
167 public override void Interact(AbstractProductA a)
168 {
169
170 Console.WriteLine( this .GetType().Name +
171
172 " interacts with " + a.GetType().Name);
173
174 }
175
176 }
177
178
179
180 /// <summary>
181
182 /// The 'ProductA2' class
183
184 /// </summary>
185
186 class ProductA2 : AbstractProductA
187 {
188
189 }
190
191
192
193 /// <summary>
194
195 /// The 'ProductB2' class
196
197 /// </summary>
198
199 class ProductB2 : AbstractProductB
200 {
201
202 public override void Interact(AbstractProductA a)
203 {
204
205 Console.WriteLine( this .GetType().Name +
206
207 " interacts with " + a.GetType().Name);
208
209 }
210
211 }
212
213
214
215 /// <summary>
216
217 /// The 'Client' class. Interaction environment for the products.
218
219 /// </summary>
220
221 class Client
222 {
223
224 private AbstractProductA _abstractProductA;
225
226 private AbstractProductB _abstractProductB;
227
228
229
230 // Constructor
231
232 public Client(AbstractFactory factory)
233 {
234
235 _abstractProductB = factory.CreateProductB();
236
237 _abstractProductA = factory.CreateProductA();
238
239 }
240
241
242
243 public void Run()
244 {
245
246 _abstractProductB.Interact(_abstractProductA);
247
248 }
249
250
251
252
253 }
结果：
下面代码是一款计算机游戏使用不同的工厂创建不同的动物世界。虽然由Continent工厂创建的动物不同，但是动物之间的关联仍然是相同的。
1 class MainApp
2 {
3
4 /// <summary>
5
6 /// Entry point into console application.
7
8 /// </summary>
9
10 public static void Main()
11 {
12
13 // Create and run the African animal world
14
15 ContinentFactory africa = new AfricaFactory();
16
17 AnimalWorld world = new AnimalWorld(africa);
18
19 world.RunFoodChain();
20
21
22
23 // Create and run the American animal world
24
25 ContinentFactory america = new AmericaFactory();
26
27 world = new AnimalWorld(america);
28
29 world.RunFoodChain();
30
31
32
33 // Wait for user input
34
35 Console.ReadKey();
36
37 }
38
39 }
40
41
42
43
44
45 /// <summary>
46
47 /// The 'AbstractFactory' abstract class
48
49 /// </summary>
50
51 abstract class ContinentFactory
52 {
53
54 public abstract Herbivore CreateHerbivore();
55
56 public abstract Carnivore CreateCarnivore();
57
58 }
59
60
61
62 /// <summary>
63
64 /// The 'ConcreteFactory1' class
65
66 /// </summary>
67
68 class AfricaFactory : ContinentFactory
69 {
70
71 public override Herbivore CreateHerbivore()
72 {
73
74 return new Wildebeest();
75
76 }
77
78 public override Carnivore CreateCarnivore()
79 {
80
81 return new Lion();
82
83 }
84
85 }
86
87
88
89 /// <summary>
90
91 /// The 'ConcreteFactory2' class
92
93 /// </summary>
94
95 class AmericaFactory : ContinentFactory
96 {
97
98 public override Herbivore CreateHerbivore()
99 {
100
101 return new Bison();
102
103 }
104
105 public override Carnivore CreateCarnivore()
106 {
107
108 return new Wolf();
109
110 }
111
112 }
113
114
115
116 /// <summary>
117
118 /// The 'AbstractProductA' abstract class
119
120 /// </summary>
121
122 abstract class Herbivore
123 {
124
125 }
126
127
128
129 /// <summary>
130
131 /// The 'AbstractProductB' abstract class
132
133 /// </summary>
134
135 abstract class Carnivore
136 {
137
138 public abstract void Eat(Herbivore h);
139
140 }
141
142
143
144 /// <summary>
145
146 /// The 'ProductA1' class
147
148 /// </summary>
149
150 class Wildebeest : Herbivore
151 {
152
153 }
154
155
156
157 /// <summary>
158
159 /// The 'ProductB1' class
160
161 /// </summary>
162
163 class Lion : Carnivore
164 {
165
166 public override void Eat(Herbivore h)
167 {
168
169 // Eat Wildebeest
170
171 Console.WriteLine( this .GetType().Name +
172
173 " eats " + h.GetType().Name);
174
175 }
176
177 }
178
179
180
181 /// <summary>
182
183 /// The 'ProductA2' class
184
185 /// </summary>
186
187 class Bison : Herbivore
188 {
189
190 }
191
192
193
194 /// <summary>
195
196 /// The 'ProductB2' class
197
198 /// </summary>
199
200 class Wolf : Carnivore
201 {
202
203 public override void Eat(Herbivore h)
204 {
205
206 // Eat Bison
207
208 Console.WriteLine( this .GetType().Name +
209
210 " eats " + h.GetType().Name);
211
212 }
213
214 }
215
216
217
218 /// <summary>
219
220 /// The 'Client' class
221
222 /// </summary>
223
224 class AnimalWorld
225 {
226
227 private Herbivore _herbivore;
228
229 private Carnivore _carnivore;
230
231
232
233 // Constructor
234
235 public AnimalWorld(ContinentFactory factory)
236 {
237
238 _carnivore = factory.CreateCarnivore();
239
240 _herbivore = factory.CreateHerbivore();
241
242 }
243
244
245
246 public void RunFoodChain()
247 {
248
249 _carnivore.Eat(_herbivore);
250
251 }
252
253 }
结果：
本文转自麒麟博客园博客，原文链接：http://www.cnblogs.com/zhuqil/archive/2010/11/29/1890969.html，如需转载请自行联系原作者
