设计模式 - Factory 工厂模式

工厂模式属于创建型模式，主要分为:简单工厂模式，工厂方法模式，抽象工厂模式

简单工厂模式

主要特点就是需要在工厂类中做判断，从而创造相应的产品，当增加新的产品时，需要修改工厂类。举例，有家生产处理器核的厂家，仅有一家工厂，能生产两种型号的处理器，客户需要什么样的处理器，一定要显式地告诉工厂生产。

例:

enum CTYPE {COREA, COREB};

class SingleCore {
    public:
    virtual void show() = 0;
};

//单核A 
class SingleCoreA: public SingleCore {
    public:
    void show() { cout << "SingleCore A" << endl; }
};
//单核B  
class SingleCoreB: public SingleCore {
    public:
    void show() { cout << "SingleCore B" << endl; }
};

//唯一的工厂，可以生产两种型号的处理器核，在内部判断 
class Factory {
    public:
    SingleCore* createSingleCore(enum CTYPE core) {
        if(core == COREA) { 
            return new SingleCoreA(); 
        }else if(core == COREB) {
            return new SingleCoreB();
        }else 
            return nullptr;
    }
};

缺点：

如果增加新的处理器核类型，只能通过修改工厂类代码增加处理器的类型，这就违反了开闭原则:对扩展开放，对更改封闭。

因此工厂方法模式出现了，即定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类。

 

---

Factory Method

---

 接着举例：这家生产处理器核的厂家赚到飞天，就决定再开设一个工厂专门生产B型号的单核，而原来的工厂专门原来生产A单核。如此，客户有需求就直接找生产对应核的工厂就可以，无须告诉工厂需要什么样的核。

例子:

class SingleCore {
    public:
    virtual void show() = 0;
};

//单核A 
class SingleCoreA: public SingleCore {
    public:
    void show() { cout << "SingleCore A" << endl; }
};
//单核B  
class SingleCoreB: public SingleCore {
    public:
    void show() { cout << "SingleCore B" << endl; }
};

class Factory {
    public:
    virtual SingleCore* createSingleCore() = 0;
};
//生产A核的工厂 
class FactoryA :public Factory{
    public:
    SingleCoreA* createSingleCore() {return new SingleCoreA();}
};

//生产B核的工厂 
class FactoryB :public Factory{
    public:
    SingleCoreB* createSingleCore() {return new SingleCoreB();}
};

当然，工厂方法模式也有缺点，新的工厂会随着新产品的增加而增加，会需要很多的类定义。

动机

• 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

模式定义

• 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。 ——《设计模式》GoF

要点总结

• Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
• Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
• Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。

 

---

 

Abstract Factory

---

 

随着这家公司技术不断进步，可以生产多核处理器了，抽象工厂模式中，提供一个创建一系列相关或依赖对象的接口，而无须为相关联的不同产品分别指定具体的类。同样，该厂家开设两家工厂，一个专门生产A型号的单核与多核处理器，另一个专门生产B型号的单核与多核处理器。实现如下：

#include <iostream>

using namespace std;

class SingleCore {
   public:
    virtual void show() = 0;
};

//单核A
class SingleCoreA : public SingleCore {
   public:
    void show() { cout << "SingleCore A" << endl; }
};
//单核B
class SingleCoreB : public SingleCore {
   public:
    void show() { cout << "SingleCore B" << endl; }
};

//多核
class MultiCore {
   public:
    virtual void show() = 0;
};

class MultiCoreA : public MultiCore {
   public:
    void show() { cout << "MultiCore A" << endl; }
};

class MultiCoreB : public MultiCore {
   public:
    void show() { cout << "MultiCore B" << endl; }
};

//工厂
class Factory {
   public:
    virtual SingleCore* createSingleCore() = 0;
    virtual MultiCore* createMultiCore() = 0;
};

//工厂A，专门用来生产A型号的处理器
class FactoryA : public Factory {
   public:
    SingleCoreA* createSingleCore() { return new SingleCoreA; }
    MultiCoreA* createMultiCore() { return new MultiCoreA; }
};

//工厂B，专门用来生产B型号的处理器
class FactoryB : public Factory {
   public:
    SingleCoreB* createSingleCore() { return new SingleCoreB(); }
    MultiCoreB* createMultiCore() { return new MultiCoreB(); }
};

int main() {
    FactoryA* factoryA = new FactoryA();
    FactoryB* factoryB = new FactoryB();
    factoryA->createSingleCore()->show();
    factoryA->createMultiCore()->show();
    factoryB->createSingleCore()->show();
    factoryB->createMultiCore()->show();
    return 0;
}

动机

• 在软件系统中，经常面临着“一系列相互依赖的对象工作”；同时，由于需求的变化，往往存在更多系列对象的创建工作。
• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合。

模式定义

• 提供一个接口，让该接口负责创建一系列”相关或者相互依赖的对象“，无需指定它们具体的类。 ——《设计模式》GoF

要点总结

• 如果没有应对”多系列对象创建“的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂即可。
• ”系列对象“指的是在某一个特定系列的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
• Abstract Factory模式主要在于应用”新系列“的需求变动。其缺点在与难以应对”新对象“的需求变动。