设计模式——Factory Method

这一篇介绍一下 GoF设计模式中的 Factory Method 模式

Factory Method

• 通过“对象创建” 模式绕开 new，来避免对象创建(new)过程中所导致的紧耦合(依赖具体类)，从而支持对象创建的稳定，它是接口抽象之后的第一步工作
• 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化

GoF设计模式对 Factory Method 的定义

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

Structure

Code

/* 未使用工厂方法模式，在Test类中的run方法中需要依靠具体的类创建对象，
   违背了依赖倒置原则，如果run方法需要调用其他的具体类创建对象，
   run的代码就需改动
*/

#include <iostream>
using namespace std;

/* 方法接口 */
class InterMethod {
public:
	/* 接口类的虚方法，等待派生类实现具体的方法 */
	virtual void method() = 0;
	/* 要实现实现多态时，基类的析构函数一般是必须要定义为虚函数，才能正确调用到派生类的析构函数 */
	virtual ~InterMethod() { }
};

/* 方法1 */
class Method1 : public InterMethod {
public:
	virtual void method() {
		cout << "method1" << endl;
	}
};

/* 方法2 */
class Method2 : public InterMethod {
public:
	virtual void method() {
		cout << "method2" << endl;
	}
};

/* 方法3 */
class Method3 : public InterMethod {
public:
	virtual void method() {
		cout << "method3" << endl;
	}
};

/* 更多方法... */


/* 调用不同方法执行 */
class Test {
public:
	void run() {
		/* 此处需要依赖 Method1 这个具体的类，违背了依赖倒置原则 */
		interMethod = new Method1;
		interMethod->method();
	}
	
	~Test() {
		delete interMethod;
	}

private:
	InterMethod* interMethod;
};

int main() {
	Test().run();
	system("pause");
	return 0;
}

/* 使用工厂方法模式，在Test类中的run方法中不需要依靠具体的类创建对象，
   如果run方法需要调用其他的具体类创建对象，run的代码不需改动
*/

#include <iostream>
using namespace std;

/* 方法接口 */
class InterMethod {
public:
	/* 接口类的虚方法，等待派生类实现具体的方法 */
	virtual void method() = 0;
	/* 要实现实现多态时，基类的析构函数一般是必须要定义为虚函数，才能正确调用到派生类的析构函数 */
	virtual ~InterMethod() { }
};

/* 工厂接口 */ 
class Factory {
public:
	/* 创建的接口 */
	virtual InterMethod* create() = 0;
	virtual ~Factory() { }
};

/* 方法1 */
class Method1 : public InterMethod {
public:
	virtual void method() {
		cout << "method1" << endl;
	}
};

/* 方法1的工厂 */
class Method1Factory : public Factory {
public:
	virtual InterMethod* create() {
		method1 = new Method1;
		return method1;
	}

	~Method1Factory() {
		delete method1;
	}

private:
	Method1* method1;
};

/* 方法2 */
class Method2 : public InterMethod {
public:
	virtual void method() {
		cout << "method2" << endl;
	}
};

/* 方法2的工厂 */
class Method2Factory : public Factory {
public:
	virtual InterMethod* create() {
		method2 = new Method2;
		return method2;
	}

	~Method2Factory() {
		delete method2;
	}

private:
	Method2* method2;
};

/* 方法3 */
class Method3 : public InterMethod {
public:
	virtual void method() {
		cout << "method3" << endl;
	}
};

/* 方法3的工厂 */
class Method3Factory : public Factory {
public:
	virtual InterMethod* create() {
		method3 = new Method3;
		return method3;
	}

	~Method3Factory() {
		delete method3;
	}

private:
	Method3* method3;
};

/* 更多方法... */


/* 调用不同方法执行 */
class Test {
public:
	Test(Factory* factory)
		: factory(factory)
	{ }

	void run() {
		/* 此处不再需要依赖 Method1 这个具体的类 */
		InterMethod* method = factory->create();
		method->method();
	}

	~Test() {
		delete factory;
	}

private:
	Factory* factory;
};

int main() {
	Test(new Method1Factory).run();
	system("pause");
	return 0;
}

总结

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

如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢