Factory Method
动机（Motivation）
- 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
- 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？
模式定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。
——《设计模式》GoF
要点总结
- Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
- Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
- Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。
代码结构
.
├── build.sh
├── clearBuild.sh
├── CMakeLists.txt
├── src
│ ├── examStu.cpp
│ ├── include
│ │ └── examStu.h
│ └── main.cpp
源码例子
examStu.h
#ifndef _EXANSTU__
#define _EXANSTU__
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef enum _eShoesType{
SHOES_TYPE_BASE = 0,
SHOES_TYPE_NIKE = 1,
SHOES_TYPE_ADIDAS = 2,
SHOES_TYPE_HUILI = 3,
SHOES_TYPE_ERROR = -1
}eShoesType;
class ShoesBase
{
public:
ShoesBase(){
cout << "ShoesBase() "<<endl;}
virtual ~ShoesBase(){
cout << "~ShoesBase() "<<endl;}
virtual void ShowTag()=0;
private:
int _shoesBase;
};
class NikeShoes :public ShoesBase
{
public:
NikeShoes(){
cout << "NikeShoes() "<<endl;}
virtual ~NikeShoes(){
cout << "~NikeShoes() "<<endl;}
void ShowTag() override {
cout << "NikeShoes::ShowTag() called"<<endl;}
private:
};
class AdidasShoes: public ShoesBase
{
public:
AdidasShoes(){
cout << "AdidasShoes() "<<endl;}
virtual ~AdidasShoes(){
cout << "~AdidasShoes() "<<endl;}
void ShowTag() override {
cout << "AdidasShoes::ShowTag() called"<<endl;}
};
class HuiLiShoes: public ShoesBase
{
public:
HuiLiShoes(){
cout << "HuiLiShoes() "<<endl;}
virtual ~HuiLiShoes(){
cout << "~HuiLiShoes() "<<endl;}
void ShowTag() override {
cout << "HuiLiShoes::ShowTag() called"<<endl;}
};
class ShoesFactory
{
public:
ShoesFactory(){
cout << "ShoesFactory() "<<endl;}
virtual ~ShoesFactory(){
cout << "~ShoesFactory() "<<endl;}
virtual std::shared_ptr<ShoesBase> CreateShoes() = 0;
};
class NikeShoesFactory :public ShoesFactory
{
public:
NikeShoesFactory(){
cout << "NikeShoesFactory() "<<endl;}
virtual ~NikeShoesFactory(){
cout << "~NikeShoesFactory() "<<endl;}
std::shared_ptr<ShoesBase> CreateShoes() override{
std::shared_ptr<ShoesBase> pNikeShoes = std::make_shared<NikeShoes>();
return pNikeShoes;
}
private:
};
class AdidasShoesFactory :public ShoesFactory
{
public:
AdidasShoesFactory(){
cout << "AdidasShoesFactory() "<<endl;}
virtual ~AdidasShoesFactory(){
cout << "~AdidasShoesFactory() "<<endl;}
std::shared_ptr<ShoesBase> CreateShoes() override {
std::shared_ptr<ShoesBase> pAdidasShoes = std::make_shared<AdidasShoes>();
return pAdidasShoes;
}
private:
};
class HuiLiShoesFactory :public ShoesFactory
{
public:
HuiLiShoesFactory(){
cout << "HuiLiShoesFactory() "<<endl;}
virtual ~HuiLiShoesFactory(){
cout << "~HuiLiShoesFactory() "<<endl;}
std::shared_ptr<ShoesBase> CreateShoes() override{
std::shared_ptr<ShoesBase> pHuiLiShoes = std::make_shared<HuiLiShoes>();
return pHuiLiShoes;
}
private:
};
#endif
main.cpp
#include <iostream>
#include <string.h>
#include <memory>
#include "examStu.h"
using namespace std;
int main(int argc, char *argv[])
{
auto pAdidasShoesFactory = std::make_shared<AdidasShoesFactory>();
std::shared_ptr<ShoesBase> pAdidasshoes = pAdidasShoesFactory->CreateShoes();
pAdidasshoes->ShowTag();
return 0;
}