前言
一、“单一职责” 模式
通过“对象创建”模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
典型模式
Factory Method
Abstract Factory
Prototype
Builder
二、Factory Method 工厂方法
1、动机
在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？
2、模式定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。
注："解耦"是解new和后面具体的类的耦合。
3、伪代码示例
原始代码：
class BinarySplitter { public: void split() { //... } };
MainForm.cpp
//MainForm.cpp 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 splitter(filePath, number, progressBar); splitter.split(); } };
未来可能的需求：文本分割，图片分割，那就要新增：
class ISplitter { public: virtual void split() = 0; virtual ~ISplitter() { } } class BinarySplitter : public ISplitter { virtual void split() { //... } }; //新增 class TxtSplitter : public ISplitter { virtual void split() { //... } }; class PictureSplitter : public ISplitter { virtual void split() { //... } }; class VideoSplitter : public ISplitter { virtual void split() { //... } };
面向接口编程最简单的表现就是变量是接口类型
MainForm1.cpp
//MainForm1.cpp class MainForm : public Form { TextBox* txtFilePath; TextBox* txtFileNumber; public: void Button1_Click(){ string filePath = txtFilePath->getText(); int number = atoi(txtFileNumber->getText().c_str()); //ISplitter* splitter 是抽象依赖 //new BinarySplitter(filePath, number) 是细节依赖，编译时细节依赖， 违背了依赖倒置原则，如何解决呢？ ISplitter* splitter = new BinarySplitter(filePath, number); //依赖具体类 splitter.split(); } };
”对象创建“ 模式就是要绕开这个new 带来的问题，这是面向接口编程必然要面临的需求，上述代码中的第13行等号左右两边都变成依赖抽象。可以考虑通过一个方法返回对象。
SplitterFactory1.cpp
//SplitterFactory1.cpp //抽象类 class ISplitter { public: virtual void split() = 0; virtual ~ISplitter() { } } //工厂基类 class SplitterFactory { public: ISplitter* createSplitter() { return new BinaryFiltter(); } };
MainForm2.cpp
//MainForm2.cpp class MainForm : public Form { TextBox* txtFilePath; TextBox* txtFileNumber; public: void Button1_Click(){ string filePath = txtFilePath->getText(); int number = atoi(txtFileNumber->getText().c_str()); SplitterFactory factory; ISplitter* splitter = factory.createSplitter(); splitter.split(); } };
因为 SplitterFactory 编译时依赖了 BinarySplitter，而 MainForm 编译时依赖了 SplitterFactory，所以相当于MainForm 编译时依赖了 BinarySplitter，所以还是没有解决问题。那应该怎么办呢？
虚函数是运行时依赖，所以修改 SplitterFactory.cpp:
SplitterFactory.cpp
//SplitterFactory.cpp class SplitterFactory { public: virtual ISplitter* createSplitter() = 0; virtual ~SplitterFactory() { } }; class ISplitter { public: virtual void split() = 0; virtual ~ISplitter() { } }
MainForm3.cpp
//MainForm3.cpp class MainForm : public Form { TextBox* txtFilePath; TextBox* txtFileNumber; public: void Button1_Click(){ string filePath = txtFilePath->getText(); int number = atoi(txtFileNumber->getText().c_str()); SplitterFactory* factory; ISplitter* splitter = factory->createSplitter(); //多态 splitter.split(); } };
未来的对象实际是什么类型依赖于 factory，那么 factory 的实际类型是什么呢：
FileSplitter2.cpp
//FileSplitter2.cpp //具体类 class BinarySplitter : public ISplitter { virtual void split() { //... } }; class TxtSplitter : public ISplitter { virtual void split() { //... } }; class PictureSplitter : public ISplitter { virtual void split() { //... } }; class VideoSplitter : public ISplitter { virtual void split() { //... } }; //具体工厂 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(); } };
MainForm3.cpp
//MainForm3.cpp class MainForm : public Form { SplitterFactory* factory; //工厂 public: MainForm(SplitterFactory* factory) { this->factory = factory; } void Button1_Click(){ ISplitter* splitter = factory->createSplitter(); //多态new splitter.split(); } };
可以发现，通过这种改善，MainForm 只依赖 SplitterFactory 和 ISplitter 这两个抽象，而没有依赖具体类。不是消灭变化，而是将变化赶到一个局部的地方。
4、结构
【注】：
Product -> ISplitter (稳定)
Creator -> SplitterFactory （稳定）
ConcreteProduct -> XXSplitter （变化）
ConcreteCreator -> XXSplitterFactory （变化）
总结
Factory Method 模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系（new）会导致软件的脆弱。
Factory Method 模式通过面向对象【注：多态】的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。【注：“延迟” 对应到代码中就是 MainForm 类中，一开始只要有需求变化，就要修改对应的代码，而改善后 MainForm 中不会因为需求的变化而进行更改，只需要加子类和子类的工厂即可，然后将具体的类传给 MainForm。】
Factory Method 模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。
