2.工厂模式

https://www.cnblogs.com/cxjchen/p/3143633.html

背景：假如不使用工厂模式，只用AbstractProduct和它的子类，当客户端每次使用子类的时候，都需要知道到底使用的是哪一个子类。当子类比较多的时候管理起来比较麻烦。

1.简单工厂

深度截图_选择区域_20201120135625.png

简单来说：简单工厂，只有一个简单工厂类，工厂类中创建产品的方法，根据传入产品的type，来创建不同的产品。
客户端：看到的是产品的抽象，无需关心返回的到底是哪个子类。客户端唯一需要知道的子类：是工厂的子类。使用的时候也是使用工厂的抽象类，达到了依赖转置的效果。
缺点：

• 每添加一个产品子类，都需要在工厂实现类，创建产品的方法中增加一个分支，违背了开放-封闭原则；
• 要求产品有相同的方法名。

 1 #include "SimpleFactory.h"
 2 
 3 
 4 int main(){
 5     AbstractFactory* factory = new SimpleFactory();
 6     AbstractProduct* product = factory->createProduct(1);
 7     product->operation();
 8     delete product;
 9     product = NULL;
10     
11     product = factory->createProduct(2);
12     product->operation();
13     delete product;
14     product = NULL;
15     return 0;
16 }

2.工厂模式(多工厂模式)

目的：解决简单工厂存在的违反开放-闭合原则的问题。

深度截图_选择区域_20201120142428.png

简单来说：每个产品提供一个对应的工厂类，通过创建不同工厂来创建不同的产品。每次添加产品的时候，只需要添加一个工厂之类就可以了。完美遵循了开放－闭合原则。

 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5     AbstractFactory* factory = new FactoryA();
 6     AbstractProduct* product = factory->createProduct();
 7     product->operation();
 8     delete product;
 9     product = NULL;
10     delete factory;
11     factory = NULL;
12     
13     factory = new FactoryB();
14     product = factory->createProduct();
15     product->operation();
16     delete product;
17     product = NULL;
18     delete factory;
19     factory = NULL;
20     return 0;
21 }

3.抽象工厂

简单工厂模式和工厂模式的缺点：产品子类必须是同一类性的，拥有共同的方法。限制了子类的扩展。
为了更好的扩展，抽象工厂就将同一类产品的子类归为一类，让他们继承同一个抽象子类。

深度截图_选择区域_20201120143921.png

简单来说：多个工厂，每一个工厂子类负责产生一簇产品，而子类的方法产生一种类型的产品。
客户端：需要知道使用哪一个工厂，并且该工厂对应可以生产的产品簇。

 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5 
 6     AbstractFactory* factory = new Factory1();
 7     AbstractProductA* productA = factory->createProductA();
 8     AbstractProductB* productB = factory->createProductB();
 9     productA->operationA();
10     productB->operationB();
11     
12     delete factory;
13     factory = NULL;
14     delete productA;
15     productA = NULL;
16     delete productB;
17     productB = NULL;
18     
19     factory = new Factory2();
20     productA = factory->createProductA();
21     productB = factory->createProductB();
22     productA->operationA();
23     productB->operationB();
24     
25     delete factory;
26     factory = NULL;
27     delete productA;
28     productA = NULL;
29     delete productB;
30     productB = NULL;
31     return 0;
32 }