每周一个设计模式之工厂方法与抽象工厂

工厂方法模式与抽象工厂模式，两个模式比较相似，把任何一个独立出来，好像都不太好，所以把它们放到一起来理解会更好。不管是工厂方法还是抽象工厂，都有三个要素，那就是Client，Factory，Product。

首先看一下工厂方法模式：

定义一个创建对象的接口，然后把对象的创建放到子类中进行。也就是说，我们要定义一个IFactory（可以是类，抽象类，也可以是接口），然后有一些具体的Factory继承自它，如AFactory，BFactory等。然后Product的创建就放到AFactory或BFactory来实现。注意这里，一个Factory只生产一种Product，这一点很重要。一个现实的例子就是，假如我们（Client）要配一台电脑（主机PC+显示器Screen），我们就要去不同的厂家（IFactory）去购买。过程为：

Client à Factory à Product à Client。我们用代码表示如下：

9 public class Product

10 {

11 //...

12 }

13 public class PC : Product

14 {

15 //...

16 }

17 public class Screen : Product

18 {

19 //...

20 }

21 public interface IFactory

22 {

23 Product CreateProduct();

24 }

25 public class PCFactory : IFactory

26 {

27 public Product CreateProduct()

28 {

29 return new PC();

30 }

31 }

32 public class ScreenFactory : IFactory

33 {

34 public Product CreateProduct()

35 {

36 return new Screen();

37 }

38 }

40 public class Client

41 {

42 public void BuySome()

43 {

44 List<IFactory> factories = new List<IFactory>();

45 factories.Add(new PCFactory());

46 factories.Add(new ScreenFactory());

47

48 foreach (IFactory factory in factories)

49 {

50 factory.CreateProduct();

51 //...

52 }

53 }

54 }

抽象工厂模式：

上面我们曾提到，工厂方法模式是一个Factory只产生一种Product，而对抽象工厂模式来说，就是一个工厂生产多种Product。也就是说这个时候Product已经不是一种了，而是多种。一句话，就是由一个工厂（Factory）生产不同的产品（Product）来满足Client的需求。

代码如下：

9 public class PCProduct

10 {

11 //...

12 }

13 public class ScreenProduct

14 {

15

16 }

17 public class APC : PCProduct

18 {

19 //...

20 }

21 public class BPC : PCProduct

22 {

23 //...

24 }

25 public class AScreen : ScreenProduct

26 {

27 //...

28 }

29 public class BScreen : ScreenProduct

30 {

31 //...

32 }

33 public interface IFactory

34 {

35 PCProduct CreatePCProduct();

36 ScreenProduct CreateScreenProduct();

37

38 }

39 public class AFactory : IFactory

40 {

41 public PCProduct CreatePCProduct()

42 {

43 return new APC();

44 }

45

46 public ScreenProduct CreateScreenProduct()

47 {

48 return new AScreen();

49 }

50 }

51 public class BFactory : IFactory

52 {

53 public PCProduct CreatePCProduct()

54 {

55 return new BPC();

56 }

57

58 public ScreenProduct CreateScreenProduct()

59 {

60 return new BScreen();

61 }

62 }

63

64 public class Client

65 {

66 public void BuySome()

67 {

68 List<IFactory> factories = new List<IFactory>();

69 factories.Add(new AFactory());

70 factories.Add(new BFactory());

71

72 foreach (IFactory factory in factories)

73 {

74 factory.CreatePCProduct();

75 factory.CreateScreenProduct();

76 //...

77 }

78 }

79 }

从上面代码，我们可以看出，从工厂方法到抽象工厂，他的变化，就在于Product由一种变成了多种，而Factory由生产一种产品变成了多种，虽然看似很小的变化，但产生的意义是很大的。

对比工厂方法，抽象工厂的意义" 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类"，我们发现，抽象工厂的对象加了形容词"一系列相关或相互依赖"。

根据他们的意义，我们可以推测他们的适用性，也就是哪里可以使用，在这里就不再叙述。