通过“对象创建”模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
典型模式（表现最为突出）
工厂方法模式：Factory Method
抽象工厂模式：Abstract Factory
原型模式：Prototype
创建者模式：Builder
一：工厂方法模式
（一）概念
工厂方法模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
（二）动机
在软件系统中，经常面临这创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合。
（三）代码讲解（同文件分割）问题提出
1.原代码
class FileSplitter
{
public:
void split(){
//...
}
};
class MainForm : public Form
{
TextBox* txtFilePath; //文件路径
TextBox* txtFileNumber; //希望分割的个数
ProgressBar* progressBar;
public:
void Button1_Click(){
//收集到用户输入的参数信息
string filePath = txtFilePath->getText();
int number = atoi(txtFileNumber->getText().c_str());
//传递给FileSplitter，让该类去分割文件
FileSplitter splitter(filePath, number, progressBar);
//进行分割
splitter.split();
}
};
动态看待问题，上面使用了具体细节类，是静态特质，定死了，我们应该去判断业务有没有需求的变化，是不是只需要文件分割。比如我们这里有变化，支持二进制，图片，视频，文本分割...，此时我们应该将他声明为抽象基类来使用
2.改进为抽象基类
class ISplitter{
public:
virtual void split()=0;
virtual ~ISplitter(){}
};
class BinarySplitter : public ISplitter{
};
class TxtSplitter: public ISplitter{
};
class PictureSplitter: public ISplitter{
};
class VideoSplitter: public ISplitter{
};
class MainForm : public Form
{
TextBox* txtFilePath;
TextBox* txtFileNumber;
ProgressBar* progressBar;
public:
void Button1_Click(){
ISplitter * splitter=
new BinarySplitter();//依赖具体类
splitter->split();
}
};
ISplitter * splitter= //依赖抽象
new BinarySplitter();//依赖具体类，依赖细节
代码当中哪怕只出现一处细节依赖，其他都是抽象依赖也解决不了问题，将该依赖倒置原则打破了，所以在编译时还是要依赖BinarySplitter才能编译通过
通过“对象创建”模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
（三）代码讲解（同文件分割）问题解决
1.改进一
我们可以使用一个方法来返回一个对象，避免直接使用new创建
class SplitterFactory : public ISplitter{
public:
ISplitter* CreateSplitter()
{
return new BinarySplitter(); //这里还是个依赖（都是编译时）
}
};
class MainForm : public Form
{
TextBox* txtFilePath;
TextBox* txtFileNumber;
ProgressBar* progressBar;
public:
void Button1_Click(){
SplitterFatory factory; //这里是个依赖
ISplitter * splitter=
factory.CreateSplitter();
splitter->split();
}
};
没有从根本解决问题，间接依赖关系，还是依赖，没有绕开这个问题。
我们可以将编译时依赖转运行时依赖，如何做：找虚函数
2.改进二：使用虚函数
class ISplitter{
public:
virtual void split()=0;
virtual ~ISplitter(){}
virtaul ISplitter* CreateSplitter()=0;
};
SplitterFatory* factory; //未来？从哪来？看下面3，可以是下面具体工厂
ISplitter * splitter=
factory->CreateSplitter(); //交给未来
3改进三：将工厂基类和抽象类解耦
//工厂基类
class SplitterFactory{
public:
virtual ISplitter* CreateSplitter()=0;
virtual ~SplitterFactory(){}
};
4.根据具体类创建一些类的具体工厂
//具体类
class BinarySplitter : public ISplitter{
};
class TxtSplitter: public ISplitter{
};
class PictureSplitter: public ISplitter{
};
class VideoSplitter: public ISplitter{
};
//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
virtual ISplitter* CreateSplitter(){
return new BinarySplitter();
}
};
class TxtSplitterFactory: public SplitterFactory{
public:
virtual ISplitter* CreateSplitter(){
return new TxtSplitter();
}
};
class PictureSplitterFactory: public SplitterFactory{
public:
virtual ISplitter* CreateSplitter(){
return new PictureSplitter();
}
};
class VideoSplitterFactory: public SplitterFactory{
public:
virtual ISplitter* CreateSplitter(){
return new VideoSplitter();
}
};
每个具体的类都有对应的具体工厂，所以我们上面的未来就有着落了
5.改进四：将未来变为字段，可以实现构造从外界传递数据修改未来
class MainForm : public Form
{
SplitterFactory* factory;//工厂，抽象基类
public:
MainForm(SplitterFactory* factory){
this->factory=factory;
}
void Button1_Click(){
ISplitter * splitter=
factory->CreateSplitter(); //多态new，通过虚函数
splitter->split();
}
};
MainForm 没有具体类的依赖了，将变化赶出去到每一个局部区域
5.程序调用：将变化赶到调用处
void proceed()
{
TxtSplitterFactory* fact=new TxtSplitterFactory();
MainForm* mf =new MainForm(fact);
}
（四）代码分析
![]()
class MainForm : public Form
{
SplitterFactory* factory;//工厂
public:
MainForm(SplitterFactory* factory){
this->factory=factory;
}
void Button1_Click(){
ISplitter * splitter=
factory->CreateSplitter(); //多态new
splitter->split();
}
};
MainForm