(本博客旨在个人总结回顾)
建议先看一下简单工厂模式,因为我的例子是在简单工厂模式上修改的。
1、详情:
工厂方法模式包含四个角色:
①抽象工厂角色:这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者是必须继承的父类。(本例中的Factory)
②具体工厂类角色:包含和具体业务逻辑相关的代码。由应用程序调用来创建对应的具体产品。(本例中的AddFactory,SubFactory,MulFactory)
③抽象产品角色:具体产品类继承的父类或者需实现的接口。(本例中的MyAlgorithm)
④具体产品角色:具体工厂角色所创建的对象实例。(本例中的MyAdd,MySub,MyMul)
2、应用:
工厂方法模式适用情况包括:一个类不知道它所需要的对象的类;一个类通过其子类来指定创建哪个对象;将创建对象的多任务委托给多个子工厂类中的某一个,客户端在使用是可以无须关心是哪一个工厂子类创建产品子类,需要是再动态指定。
3、UML类图:
4、代码实现:
MyAlgorithm.h
#pragma once
//算法接口类
class MyAlgorithm
{
public:
MyAlgorithm();
virtual ~MyAlgorithm();
public:
virtual double GetResult(double param1, double param2) = 0;
};
MyAlgorithm.cpp
#include "stdafx.h"
#include "MyAlgorithm.h"
MyAlgorithm::MyAlgorithm()
{
}
MyAlgorithm::~MyAlgorithm()
{
}
MyAdd.h
#pragma once
#include "MyAlgorithm.h"
class MyAdd:public MyAlgorithm
{
public:
MyAdd();
~MyAdd();
public:
double GetResult(double param1, double param2);
};
MyAdd.cpp
#include "stdafx.h"
#include "MyAdd.h"
MyAdd::MyAdd()
{
}
MyAdd::~MyAdd()
{
}
double MyAdd::GetResult(double param1, double param2)
{
return param1 + param2;
}
MySub.h
#pragma once
#include "MyAlgorithm.h"
class MySub:public MyAlgorithm
{
public:
MySub();
~MySub();
public:
double GetResult(double param1, double param2);
};
MySub.cpp
#include "stdafx.h"
#include "MySub.h"
MySub::MySub()
{
}
MySub::~MySub()
{
}
double MySub::GetResult(double param1, double param2)
{
return param1 - param2;
}
MyMul.h
#pragma once
#include "MyAlgorithm.h"
class MyMul:public MyAlgorithm
{
public:
MyMul();
~MyMul();
public:
double GetResult(double param1, double param2);
};
MyMul.cpp
#include "stdafx.h"
#include "MyMul.h"
MyMul::MyMul()
{
}
MyMul::~MyMul()
{
}
double MyMul::GetResult(double param1, double param2)
{
return param1 * param2;
}
Factory.h
#pragma once
#include "MyAlgorithm.h"
class Factory
{
public:
Factory();
virtual ~Factory();
public:
virtual MyAlgorithm* GetAlgorithm() = 0;
};
Factory.cpp
#include "stdafx.h"
#include "Factory.h"
Factory::Factory()
{
}
Factory::~Factory()
{
}
AddFactory.h
#pragma once
#include "Factory.h"
class AddFactory:public Factory
{
public:
AddFactory();
~AddFactory();
public:
MyAlgorithm* GetAlgorithm();
};
AddFactory.cpp
#include "stdafx.h"
#include "AddFactory.h"
#include "MyAdd.h"
AddFactory::AddFactory()
{
}
AddFactory::~AddFactory()
{
}
MyAlgorithm* AddFactory::GetAlgorithm()
{
return new MyAdd();
}
SubFactory.h
#pragma once
#include "Factory.h"
class SubFactory: public Factory
{
public:
SubFactory();
~SubFactory();
public:
MyAlgorithm* GetAlgorithm();
};
SubFactory.cpp
#include "stdafx.h"
#include "SubFactory.h"
#include "MySub.h"
SubFactory::SubFactory()
{
}
SubFactory::~SubFactory()
{
}
MyAlgorithm* SubFactory::GetAlgorithm()
{
return new MySub();
}
MulFactory.h
#pragma once
#include "Factory.h"
class MulFactory:public Factory
{
public:
MulFactory();
~MulFactory();
public:
MyAlgorithm* GetAlgorithm();
};
MulFactory.cpp
#include "stdafx.h"
#include "MulFactory.h"
#include "MyMul.h"
MulFactory::MulFactory()
{
}
MulFactory::~MulFactory()
{
}
MyAlgorithm* MulFactory::GetAlgorithm()
{
return new MyMul();
}
调用代码:
// FactoryMethodMemo.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "MyAlgorithm.h"
#include "AddFactory.h"
#include "SubFactory.h"
#include "MulFactory.h"
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
MyAlgorithm* pAlgorithmm = NULL;
Factory* pFactory = new AddFactory();
pAlgorithmm = pFactory->GetAlgorithm();
cout << "add:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
delete pAlgorithmm;
pAlgorithmm = NULL;
delete pFactory;
pFactory = NULL;
pFactory = new SubFactory();
pAlgorithmm = pFactory->GetAlgorithm();
cout << "sub:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
delete pAlgorithmm;
pAlgorithmm = NULL;
delete pFactory;
pFactory = NULL;
pFactory = new MulFactory();
pAlgorithmm = pFactory->GetAlgorithm();
cout << "mul:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
delete pAlgorithmm;
pAlgorithmm = NULL;
system("pause");
return 0;
}
输出结果: