抽象工厂

先来看看抽象工厂的UML图

看到了吧，唯一的区别就是工厂创建了多个对象，当然，还是在工厂子类中创建的，这一点和工厂模式是一致的
C#版本代码  

1. /*其实工厂和抽象工厂没有多大区别，只不过是抽象工厂生产的商品是多个而已
   
2. 通俗的说，就是抽象工厂模式的具体工厂里面会有多个实例具体对象的方法
   
3. 更直观的就是，抽象工厂模式每个工厂一次造多个玩意,而工厂模式的每个工厂只造一个玩意*/
   
4. public abstract class Product
   
5. {
   
6. public abstract void work();
   
7. }
   
8. public class ProductA : Product
   
9. {
   
10. public override void work()
    
11. {
    
12. Console.Write("ProductA");
    
13. }
    
14. }
    
15. public class ProductB : Product
    
16. {
    
17. public override void work()
    
18. {
    
19. Console.Write("ProductB");
    
20. }
    
21. }
    
22. public abstract class Car
    
23. {
    
24. public abstract void Build();
    
25. }
    
26. public class CarA : Car
    
27. {
    
28. public override void Build()
    
29. {
    
30. Console.Write("Build CarA");
    
31. }
    
32. }
    
33. public class CarB : Car
    
34. {
    
35. public override void Build()
    
36. {
    
37. Console.Write("Build CarB");
    
38. }
    
39. }
    
40. public abstract class AbstractFactory
    
41. {
    
42. //工厂生产多个对象
    
43. public abstract Product newproduct();
    
44. public abstract Car newCar();
    
45. }
    
46. public class AbstractFactoryA : AbstractFactory
    
47. {
    
48. public override Product newproduct()
    
49. {
    
50. return new ProductA();//子类里面实现具体的实例化
    
51. }
    
52. public override Car newCar()
    
53. {
    
54. return new CarA();
    
55. }
    
56. }
    
57. public class AbstractFactoryB : AbstractFactory
    
58. {
    
59. public override Product newproduct()
    
60. {
    
61. return new ProductB();//子类里面实现具体的实例化
    
62. }
    
63. public override Car newCar()
    
64. {
    
65. return new CarB();
    
66. }
    
67. }
    
68. 
    
69. public class AbstractFactoryClient
    
70. {
    
71. public static void GetFactoryMethod()
    
72. {
    
73. AbstractFactory factorysubA = new AbstractFactoryA();
    
74. AbstractFactory factorysubB = new AbstractFactoryA();
    
75. 
    
76. Product pruductA = factorysubA.newproduct();
    
77. Product pruductB = factorysubB.newproduct();
    
78. Car factorycarA = factorysubA.newCar();
    
79. 
    
80. factorycarA.Build();
    
81. 
    
82. pruductA.work();
    
83. pruductB.work();
    
84. }
    
85. }