工厂模式

简介

• 常见的实例化对象模式。

• 用工厂方法替代new操作的一种模式。

• 当我们使用new操作实例化对象时，调用构造函数完成初始化。若初始化仅是进行赋值等简单的操作，写入构造函数即可。但如果初始化时需要执行一长串复杂的代码，将多个工作装入一个方法，是不妥的。

• 创建实例与使用实例分离。将创建实例所需的大量初始化工作从基类的构造函数中分离出去。

• 简单工厂模式、工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

• 角色

  • 基类接口：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
  • 子类（实现类/产品类）：简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
  • 工厂类：产生实例。简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法（对工厂类实例化，调用方法）可以被外界直接调用，创建所需的产品对象。

• 图解
  

• 实质

  • 根据传入工厂类成员方法（实例化函数）的参数，动态创建产品类实例。

• 优点

  • 外界不必管内部究竟如何创建及组织对象的，仅仅需要负责“消费”对象即可。

• 缺点

  • 由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中。
  • 它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
  • 我们前面提到，工厂类根据传入方法的参数，动态创建产品类实例。当我们增加产品类时，工厂类方法需要增加参数，修改代码。

• 应用场景

  • 工厂类负责创建的对象比较少；
  • 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
  • 由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

• 实例

查看实例：https://blog.csdn.net/liang19890820/article/details/70652199

• 编程语言分为好多种，三大流行语言为C++、Python、Java。

• 基类：程序语言类，实现接口。

#ifndef _PARENT_H_
#define _PARENT_H_

#include<string>

using namespace std;

class Language {
public:
    virtual string name() = 0;
};

#endif // !_PARENT_H_

• 子类：各种语言，具体实现。

#ifndef _CHILD_H_
#define _CHILD_H_

#include "parent.h"

class CPlusPlus : public Language {
public:
    string name() {
        string name = "C++";
        return name;
    }
};

class Java : public Language {
public:
    string name() {
        string name = "java";
        return name;
    }
};

class Python : public Language {
public:
    string name() {
        string name = "python";
        return name;
    }
};

#endif // !_CHILD_H_

• 工厂类：实例化各个子类，创建实例。

#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "child.h"

class Factory {
public:
    Language* createLanguage(const int& flag) {
        Language *language = nullptr;
        switch (flag) {
        case 1:
            language = new CPlusPlus();
            break;
        case 2:
            language = new Java();
            break;
        case 3:
            language = new Python();
            break;
        }
        return language;
    }
};

#endif // !_FACTORY_H_

• main函数

#include<iostream>
#include"factory.h"

using namespace std;

int main(int argc, char* argv[]) {
    Factory *factor = new Factory();  //实例化工厂
    //1:C++   2:java   3:python
    for (int i = 1; i < 4; ++i) {
        //工厂类成员方法动态决定对象的实例化
        Language *language = factor->createLanguage(i);  
        cout << language->name() << endl;
    }
    getchar();
    return 0;
}

• 结果
  

工厂方法模式

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

• 实现“开—闭”原则，实现可扩展。

• 角色

  • 抽象产品（基类）：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
  • 具体产品（子类）：实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。
  • 抽象工厂：工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
  • 具体工厂：实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

• 图解
  

• 应用场景

  • 单一产品，对简单工厂模式的改进。

• 实例

查看实例：https://blog.csdn.net/liang19890820/article/details/70652858

• 计算机组件由CPU、显示屏、芯片组成。每个组件有对应的厂商。

• 基类：计算机组件。

#ifndef _PARENT_H_
#define _PARENT_H_

#include<string>

using namespace std;

class  CM{
public:
    virtual string name() = 0;
};

#endif // !_PARENT_H_

• 子类：各大组件。

#ifndef _CHILD_H_
#define _CHILD_H_

#include "parent.h"

class CPU : public CM {
public:
    string name() {
        string name = "CPU";
        return name;
    }
};

class Chip : public CM {
public:
    string name() {
        string name = "Chip";
        return name;
    }
};

class Display : public CM {
public:
    string name() {
        string name = "Display";
        return name;
    }
};

#endif // !_CHILD_H_

• 抽象工厂：对具体工厂的抽象。

#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "child.h"
#include "ConcreteFactory.h"

class AbstractFactory {
public:
    virtual CM* createCM() = 0;
};

#endif // !_FACTORY_H_

• 具体工厂：生产各大组件。

#ifndef _CONCRETEFACTORY_H_
#define _CONCRETEFACTORY_H_

#include "child.h"
#include "factory.h"

class CPUFactory : public AbstractFactory{
public:
    CM* createCM() {
        return new CPU();
    }
};

class ChipFactory : public AbstractFactory {
public:
    CM* createCM() {
        return new Chip();
    }
};

class DisplayFactory : public AbstractFactory {
public:
    CM* createCM() {
        return new Display();
    }
};

#endif // !_CONCRETEFACTORY_H_

• main函数

#include<iostream>
#include"ConcreteFactory.h"

using namespace std;

int main(int argc, char* argv[]) {

    AbstractFactory *factory = new CPUFactory();
    CM* cm = factory->createCM();
    cout << cm->name() << endl;

    factory = new ChipFactory();
    cm = factory->createCM();
    cout << cm->name() << endl;

    factory = new DisplayFactory();
    cm = factory->createCM();
    cout << cm->name() << endl;

    getchar();
    return 0;
}

• 结果
  

抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

• 简介

  • 当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

• 图解
  

• 注意

  • 创建实例和使用实例分离：系统不依赖于产品类实例如何被创建，组合和表达的细节；
  • 系统的产品有多于一个的产品族，而系统只消费其中某一族的产品；
  • 同属于同一个产品族是在一起使用的。
  • 系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。

• 优点

  • 分离了具体的类
  • 易于交换产品系列
  • 有利于产品的一致性
  • 不改变产品等级结构的情况下，增加产品族就是意味着向每一个产品等级结构中增加一个或者多个新的具体产品角色，这时只需要向工厂等级结构中增加新的元素就可以了。

• 缺点

  • 难以支持新种类的产品。在产品族数目不变的情况下，增加产品等级结构，相当于增加一个与现有产品等级结构平行的一个新的产品等级结构，这时需要向修改所有的工厂角色，增加一个新的工厂方法,这是不支持OCP（开放—封闭原则）的。

• 实例

查看实例：https://blog.csdn.net/liang19890820/article/details/70653800