3 创建型模式-----抽象工厂模式

附加概念:

产品等级结构：不同品牌的同一类产品，如Haier电视机，TCL电视机都是电视机，因此属于同一个产品等级结构。

产品族：属于同一个品牌的所有产品，如Haier电视机，Haier冰箱等。

模式动机：工厂方法模式一般针对的是一个产品等级结构（如仅生产电视机），而抽象工厂模式针对的是多个产品等级结构（如不仅生产电视机，还生产空调）。

模式定义：一个具体工厂可以创建一个产品族的所有产品，又称为Kit模式。

模式结构图：

模式代码：

bt_抽象工厂模式.h：

  1 #ifndef AFP_H
  2 #define AFP_H
  3 #include <iostream>
  4 
  5 /*
  6     抽象产品接口
  7 */
  8 class AbstractProductA
  9 {
 10 public:
 11     virtual ~AbstractProductA(){ };
 12 };
 13 
 14 class AbstractProductB
 15 {
 16 public:
 17     virtual ~AbstractProductB(){ };
 18 };
 19 
 20 /*
 21     具体产品类A
 22 */
 23 class ConcreteProductA1 : public AbstractProductA
 24 {
 25 public:
 26     ConcreteProductA1();
 27 };
 28 ConcreteProductA1::ConcreteProductA1()
 29 {
 30     std::cout << "创建产品族1中的A" << std::endl;
 31 }
 32 class ConcreteProductA2 : public AbstractProductA
 33 {
 34 public:
 35     ConcreteProductA2();
 36 };
 37 ConcreteProductA2::ConcreteProductA2()
 38 {
 39     std::cout << "创建产品族2中的A" << std::endl;
 40 }
 41 
 42 /*
 43     具体产品类B
 44 */
 45 class ConcreteProductB1 : public AbstractProductB
 46 {
 47 public:
 48     ConcreteProductB1();
 49 };
 50 ConcreteProductB1::ConcreteProductB1()
 51 {
 52     std::cout << "创建产品族1中的B" << std::endl;
 53 }
 54 class ConcreteProductB2 : public AbstractProductB
 55 {
 56 public:
 57     ConcreteProductB2();
 58 };
 59 ConcreteProductB2::ConcreteProductB2()
 60 {
 61     std::cout << "创建产品族2中的B" << std::endl;
 62 }
 63 
 64 
 65 /*
 66     抽象工厂接口
 67 */
 68 
 69 class AbstractFactory
 70 {
 71 public:
 72     virtual ~AbstractFactory(){ };
 73     virtual AbstractProductA* createProductA() = 0;
 74     virtual AbstractProductB* createProductB() = 0;
 75 };
 76 
 77 /*
 78     具体工厂ConcreteFactory1负责生产 "产品族1"
 79 */
 80 
 81 class ConcreteFactory1 : public AbstractFactory
 82 {
 83 public:
 84     virtual AbstractProductA* createProductA();
 85     virtual AbstractProductB* createProductB();
 86 };
 87 AbstractProductA* ConcreteFactory1::createProductA()
 88 {
 89     return new ConcreteProductA1;
 90 }
 91 AbstractProductB* ConcreteFactory1::createProductB()
 92 {
 93     return new ConcreteProductB1;
 94 }
 95 
 96 /*
 97     具体工厂ConcreteFactory2负责生产 "产品族2"
 98 */
 99 
100 class ConcreteFactory2 : public AbstractFactory
101 {
102 public:
103     virtual AbstractProductA* createProductA();
104     virtual AbstractProductB* createProductB();
105 };
106 AbstractProductA* ConcreteFactory2::createProductA()
107 {
108     return new ConcreteProductA2;
109 }
110 AbstractProductB* ConcreteFactory2::createProductB()
111 {
112     return new ConcreteProductB2;
113 }
114 #endif // AFP_H

bt_抽象工厂模式.cpp：

 1 #include "bt_抽象工厂模式.h"
 2 #include <iostream>
 3 
 4 int main()
 5 {
 6     std::cout << "***** 抽象工厂模式测试 *****" << std::endl;
 7     AbstractFactory* factory = NULL;
 8     AbstractProductA* pa = NULL;
 9     AbstractProductB* pb = NULL;
10 
11     factory = new ConcreteFactory1;
12     pa = factory->createProductA();
13     pb = factory->createProductB();
14 
15     std::cout << std::endl;
16     factory = new ConcreteFactory2;
17     pa = factory->createProductA();
18     pb = factory->createProductB();
19 
20     delete pb;
21     delete pa;
22     delete factory;
23 
24     return 0;
25 }

模式优缺点：

添加新的产品族（即一个新的品牌）比较容易，此时只需要定义新的工厂和产品类即可；但增加产品等级（即原有品牌的种类）比较麻烦，此时必须修改抽象工厂以添加新种类的生产接口，同时所有已有的产品族工厂也要修改，这就违背了“开闭原则”。该模式具体应用中一般适合对象的多种状态同时发生变化时，比如操作系统中的主题管理程序等。

比较：

抽象工厂模式针对的是多个产品等级，而工厂方法模式针对的是一个产品等级，抽象工厂模式经过退化后完全可以变为工厂方法模式，甚至是简单工厂模式。