8-工厂模式

“对象创建”模式

通过“对象创建”模式绕开new，来避免对象创建过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定

• Factory Method
• Abstract Factory
• Prototype
• Builder

工厂方法

BinarySplitter * splitter = new BinarySplitter();

这里要创建一个文件分割器，可能现在的文件分割器只支持二进制文件的分割，以后可能会支持文本文件、图片文件等，所以创建对象的时候不应该依赖于具体的类BinarySplitter，因为后面可能会被扩展，而应该依赖于抽象类，比如ISplitter

抽象类定义接口，具体类实现各自的接口

class ISplitter {
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

class BinarySplitter : public ISplitter {
    
};

class TxtSplitter: public ISplitter {
    
};

这样在对象创建的时候就要用基类指针指向派生类对象

class MainForm : public Form {
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;

public:
    void Button1_Click(){
        
        ISplitter * splitter = new BinarySplitter();//依赖具体类
        splitter->split();
    }
};

但这里还是有问题，new的时候还是依赖于具体类

我们的目标就是要绕开new，避免依赖具体类，都要依赖接口

可以让子类都有一个工厂用来创建对象，然后MainForm里面组合一个工厂基类的指针就行

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

//工厂基类
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter()=0;
    virtual ~SplitterFactory(){}
};


//具体类
class BinarySplitter : public ISplitter{
    
};

class TxtSplitter: public ISplitter{
    
};

//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};

class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

MainForm里面有一个工厂基类的指针，可以从外界传一个具体工厂指针进来，比如传的是BinarySplitterFactory*，这样factory->CreateSplitter()就会调用BinarySplitterFactory的CreateSplitter具体实现，创建BinarySplitter对象

class MainForm : public Form
{
    SplitterFactory* factory;//工厂

public:
    
    MainForm(SplitterFactory* factory){
        this->factory = factory;
    }
    
    void Button1_Click(){
        ISplitter * splitter = factory->CreateSplitter(); //多态new
        splitter->split();
    }
};

模式定义

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

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

简单版本

class B {
public:
    virtual void info() = 0;
};

class D1 : public B {
public:
    void info() { cout << "D1::info" << endl; }
};

class D2 : public B {
public:
    void info() { cout << "D2::info" << endl; }
};

class Factory {
public:
    virtual B* create() = 0;
};

class D1Factory : public Factory {
public:
    D1* create() {
        return new D1();
    }
};

class D2Factory : public Factory {
public:
    D2* create() {
        return new D2();
    }
};

int main(int argc, char const *argv[])
{
    Factory *pf1 = new D1Factory(); // 创建D1的工厂
    B *pb1 = pf1->create(); // 生产D1
    pb1->info();    // D1::info
    
    Factory *pf2 = new D2Factory(); // 创建D2的工厂
    B *pb2 = pf2->create(); // 生产D2
    pb2->info();    // D2::info
    return 0;
}