计划模式之抽象工厂

一、抽象工厂概念

抽象工厂模式是一种创建型计划模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
抽象工厂模式的焦点头脑是将对象的创建与利用分离开来，从而实现系统的松耦合。在抽象工厂模式中，客户端不必要知道具体产物的类名，只必要知道产物的抽象类或接口即可。
   抽象工厂模式包含以下脚色：
  1. 抽象工厂：定义了一组创建产物的方法，每个方法对应一个具体的产物族。
  2. 具体工厂：实现抽象工厂接口，负责创建一组具体的产物。
  3. 抽象产物：定义了产物的公共接口。
  4. 具体产物：实现抽象产物接口，是具体工厂创建的产物。
    抽象工厂模式的实用场景：
          1. 系统必要一组相关的产物，而这些产物之间存在肯定的关联或依赖关系。
          2. 系统必要在差别的平台或差别的环境下利用差别的产物。
          3. 系统必要提供一个产物类库，而且这些产物的实现都必须相互兼容。
    抽象工厂模式是一种创建型计划模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。抽象工厂模式是工厂方法模式的升级版，它不仅可以创建单个对象，还可以创建一系列相关的对象。
  

类图及代码如下：

1. /*  
2.     如果想要生产一条新的生产线，需要修改抽象工厂ModernFurnitureFactor及它的子类和具体工厂，
3.     还需要修改抽象产品Chair和Table，以及具体产品ModernChair和ModernTable,这违背了开闭原则
4. */
6. //
7. #include <iostream>
8. using namespace std;
10. class Chair
11. {
12. public:
13.     virtual~Chair() {}
14.     virtual void sitOn() const = 0;
16. };
17. class ModernChair: public Chair
18. {
19. public:
20.     virtual ~ModernChair() {}
21.     virtual void sitOn() const override
22.     {
23.         cout << "可以被坐下的ModernChair" << endl;
24.     }
26. };
27. class ChineseChair: public Chair
28. {
29. public:
30.     virtual~ChineseChair() {}
31.     virtual void sitOn() const override
32.     {
33.         cout << "可以被坐下的ChineseChair" << endl;
34.     }
35. };
37. class Table
38. {
39. public:
40.     virtual~Table() {}
41.     virtual void putOn() const = 0;
42. };
43. class ModernTable : public Table
44. {
45. public:
46.     virtual ~ModernTable() {}
47.     virtual void putOn() const override
48.     {
49.         cout << "ModernTable" << endl;
50.     }
51. };
52. class ChineseTable : public Table
53. {
54. public:
55.     virtual~ChineseTable() {}
56.     virtual void putOn() const override
57.     {
58.         cout << "ChineseTable" << endl;
59.     }
60. };
62. class FurnitureFactory//抽象工厂
63. {
64. public:
65.     virtual Chair* createChair() const = 0;
66.     virtual Table* createTable() const = 0;
67.     virtual ~FurnitureFactory() {}
68. };
69. class ModernStyleFactory : public FurnitureFactory
70. {
71. public:
72.     virtual Chair* createChair() const override
73.     {
74.         return new ModernChair();
75.     }
76.     virtual Table* createTable() const override
77.     {
78.         return new ModernTable();
79.     }
80. };
81. class ChineseStyleFactory : public FurnitureFactory
82. {
83. public:
84.     virtual Chair* createChair() const override
85.     {
86.         return new ChineseChair();
87.     }
88.     virtual Table* createTable() const override
89.     {
90.         return new ChineseTable();
91.     }
92. };
95. class Client
96. {
97. private:
98.     FurnitureFactory* m_factory;
99. public:
100.     Client(FurnitureFactory* factory)
101.     {
102.         setFactory(factory);
103.     }
105.     void buyFurniture()
106.     {
107.         Chair* chair = m_factory->createChair();
108.         Table* table = m_factory->createTable();
110.         chair->sitOn();
111.         table->putOn();
113.         delete chair;
114.         delete table;
115.     }
117.     void setFactory(FurnitureFactory* factory)
118.     {
119.         m_factory = factory;
120.     }
121. };
123. int main()
124. {
125.     ModernStyleFactory modernFactory;
126.     Client client(&modernFactory);
127.     client.buyFurniture();
129.     ChineseStyleFactory chineseFactory;
130.     client.setFactory(&chineseFactory);
131.     client.buyFurniture();
132.     return 0;
133. }

复制代码

二、抽象工厂的优缺点

   抽象工厂模式的长处：
          1. 可以在不修改客户端代码的情况下，更换产物系列。
          2. 可以保证客户端利用的产物是同一系列的，避免了产物之间的不兼容问题。
          3. 可以将产物的创建与利用分离开来，从而实现系统的松耦合。
  抽象工厂模式的缺点：
          1. 增加新的产物族比较困难，必要修改抽象工厂和所有的具体工厂。
          2. 增加新的产物等级结构比较困难，必要修改抽象工厂和所有的具体工厂。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。