工厂方法模式，定义一个用于创建对象的接口，让子类决定实力化哪一个类。工厂方法使一个类的实例化延迟到其子类。其UML图如下：
这里要区分一下工厂方法模式与简单工厂模式的区别。简单工厂模式需要在工厂类中判断要生产什么类型的对象。工厂方法模式则把这部分工作交给了客户端。每一种类对象都有自己的工厂，客户端根据自己的不同需要生成不同工厂，然后在生产自己需要的对象。工厂方法模式相对简单工厂模式来说降低了类与客户端的耦合度。最重要的一点是当需要添加其他的类的时候不用修改原来的代码。只需用添加响应的工厂就行了和类就行了。这样做遵循了开放-封闭原则。而简单工厂模式实际是破坏了开放-封闭原则。
其代码如下：
// FactoryMethodModel.h文件 #pragma once #include <iostream> // 操作类 template<typename T> class Operation { public: Operation(const T &lpa, const T &rpa) { this->lpa = lpa; this->rpa = rpa; } virtual T getResult() = 0; protected: T lpa, rpa; }; //加法操作 template<typename T> class AddOperation : public Operation<T> { public: AddOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa) { ; } virtual T getResult() { return this->lpa + this->rpa; } }; // 减法操作 template<typename T> class SubOperation : public Operation<T> { public: SubOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa) { ; } virtual T getResult() { return this->lpa - this->rpa; } }; // 乘法操作 template<typename T> class MulOperation : public Operation<T> { public: MulOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa) { ; } virtual T getResult() { return this->lpa * this->rpa; } }; // 除法操作 template<typename T> class DivOperation : public Operation<T> { public: DivOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa) { ; } virtual T getResult() { if (0 == this->rpa) { std::cout << "除数不能为0" << std::endl; return 0; } return this->lpa / this->rpa; } }; // 工厂类 template<typename T> class Factory { public: virtual Operation<T> * createObject(const T &lpa, const T &rpa) = 0; }; // 加法工厂 template<typename T> class AddFactory : public Factory<T> { public: virtual Operation<T> * createObject(const T &lpa,const T &rpa) { return new AddOperation<T>(lpa, rpa); } }; // 减法工厂 template<typename T> class SubFactory : public Factory<T> { public: virtual Operation<T> * createObject(const T &lpa, const T &rpa) { return new SubOperation<T>(lpa, rpa); } }; // 乘法工厂 template<typename T> class MulFactory : public Factory<T> { public: virtual Operation<T> * createObject(const T &lpa, const T &rpa) { return new MulOperation<T>(lpa, rpa); } }; // 除法工厂 template<typename T> class DivFactory : public Factory<T> { public: virtual Operation<T> * createObject(const T &lpa,const T &rpa) { return new DivOperation<T>(lpa, rpa); } };测是代码如下：
#include <iostream> #include "FactoryMethodModel.h" int main() { using namespace std; // 工厂方法模式,与简单工厂模式的区别就是简单工厂模式中需要由工厂 // 来判断生成什么类型的Operation，而工厂方法模式则由客户端来判断 // 需要什么类型的操作则创建什么样的工厂，这样耦合度更低。添加类型 // 方法类型的时候不用修改原来的代码，遵从了开放-封闭原则。 double a = 1384.348, b = 109348.9785234; Factory<double> *p = new AddFactory<double>; Operation<double> * oper = p->createObject(a, b); double d = oper->getResult(); cout << oper->getResult() << endl; delete oper; delete p; p = new SubFactory<double>; oper = p->createObject(a, b); cout << oper->getResult() << endl; delete oper; delete p; p = new MulFactory<double>; oper = p->createObject(a, b); cout << oper->getResult() << endl; delete oper; delete p; p = new DivFactory<double>; oper = p->createObject(a, b); cout << oper->getResult() << endl; delete oper; delete p; getchar(); return 0; }测试结果如下图：
