Factory
1、定义创建对象的接口，封装对象的创建
2、将实际创建工作延迟到子类中，例如，类A中药使用类B,B是抽象父类，但是在类A中不知道具体要实例化哪一个B的子类，但是在类A的子类D中是可以知道的。在A中无法使用 new B***()方法
3、将创建工作延迟到子类中后，核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂，只提供工厂子类必须实现的接口，这样的好处是可以不用修改已有的工厂类的情况下增加新的产品（每一种产品，都分别对应相应的工厂子类负责其创建工作）
使用场景：用于一类类（所创建的产品继承共同的产品基类）的创建
实现方式1：所谓的工厂方法模式，对每一个子类产品都分别对应一个工厂子类，用来创建相应的产品，这样若增加了新的产品，只需相应增加工厂子类即可
优点：不用修改已有代码，开放封闭原则：对扩展开放，对更改封闭
代码如下：
//IHuman.h #pragma once
class IHuman
{
public:
IHuman(void)
{
}
virtual ~IHuman(void)
{
}
virtual void Laugh() = ;
virtual void Cry() = ;
virtual void Talk() = ;
}; //YellowHuman.h #pragma once
#include "ihuman.h"
class CYellowHuman :
public IHuman
{
public:
CYellowHuman(void);
~CYellowHuman(void);
void Laugh();
void Cry();
void Talk();
}; //YellowHuman.cpp #include "StdAfx.h"
#include "YellowHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CYellowHuman::CYellowHuman(void)
{
}
CYellowHuman::~CYellowHuman(void)
{
}
void CYellowHuman::Cry()
{
cout << "黄色人种会哭" << endl;
}
void CYellowHuman::Laugh()
{
cout << "黄色人种会大笑，幸福呀！" << endl;
}
void CYellowHuman::Talk()
{
cout << "黄色人种会说话，一般说的都是双字节" << endl;
} //WhiteHuman.h #pragma once
#include "ihuman.h"
class CWhiteHuman :
public IHuman
{
public:
CWhiteHuman(void);
~CWhiteHuman(void);
void Laugh();
void Cry();
void Talk();
}; //WhiteHuman.cpp #include "StdAfx.h"
#include "WhiteHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CWhiteHuman::CWhiteHuman(void)
{
}
CWhiteHuman::~CWhiteHuman(void)
{
}
void CWhiteHuman::Cry()
{
cout << "白色人种会哭" << endl;
}
void CWhiteHuman::Laugh()
{
cout << "白色人种会大笑，侵略的笑声" << endl;
}
void CWhiteHuman::Talk()
{
cout << "白色人种会说话，一般都是单字节" << endl;
} //BlackHuman.h #pragma once
#include "ihuman.h"
class CBlackHuman :
public IHuman
{
public:
CBlackHuman(void);
~CBlackHuman(void);
void Laugh();
void Cry();
void Talk();
}; //BlackHuman.cpp #include "StdAfx.h"
#include "BlackHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CBlackHuman::CBlackHuman(void)
{
}
CBlackHuman::~CBlackHuman(void)
{
}
void CBlackHuman::Cry()
{
cout << "黑人会哭" << endl;
}
void CBlackHuman::Laugh()
{
cout << "黑人会笑" << endl;
}
void CBlackHuman::Talk()
{
cout << "黑人可以说话，一般人听不懂" << endl;
} //IHumanFactory.h #pragma once
#include "IHuman.h"
class IHumanFactory
{
public:
IHumanFactory(void)
{
}
virtual ~IHumanFactory(void)
{
}
virtual IHuman * CreateHuman() = ;
};
//YellowHuman.h #pragma once
#include "ihumanfactory.h"
class CYellowHumanFactory :
public IHumanFactory
{
public:
CYellowHumanFactory(void);
~CYellowHumanFactory(void);
virtual IHuman * CreateHuman(void);
}; //YellowHumanFactory.cpp #include "StdAfx.h"
#include "YellowHumanFactory.h"
#include "YellowHuman.h"
CYellowHumanFactory::CYellowHumanFactory(void)
{
}
CYellowHumanFactory::~CYellowHumanFactory(void)
{
}
IHuman * CYellowHumanFactory::CreateHuman( void )
{
return new CYellowHuman();
}
//WhiteHuman.h #pragma once
#include "ihumanfactory.h"
class CWhiteHumanFactory :
public IHumanFactory
{
public:
CWhiteHumanFactory(void);
~CWhiteHumanFactory(void);
virtual IHuman * CreateHuman(void);
}; //WhiteHumanFactory.cpp #include "StdAfx.h"
#include "WhiteHumanFactory.h"
#include "WhiteHuman.h"
CWhiteHumanFactory::CWhiteHumanFactory(void)
{
}
CWhiteHumanFactory::~CWhiteHumanFactory(void)
{
}
IHuman * CWhiteHumanFactory::CreateHuman( void )
{
return new CWhiteHuman();
}
//BlackHuman.h #pragma once
#include "ihumanfactory.h"
class CBlackHumanFactory :
public IHumanFactory
{
public:
CBlackHumanFactory(void);
~CBlackHumanFactory(void);
virtual IHuman * CreateHuman();
};
//BlackHumanFactory.cpp #include "StdAfx.h"
#include "BlackHumanFactory.h"
#include "BlackHuman.h"
CBlackHumanFactory::CBlackHumanFactory(void)
{
}
CBlackHumanFactory::~CBlackHumanFactory(void)
{
}
IHuman * CBlackHumanFactory::CreateHuman()
{
return new CBlackHuman();
} //FactoryMethod.cpp // FactoryMethod.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "IHuman.h"
#include "YellowHuman.h"
#include "WhiteHuman.h"
#include "BlackHuman.h"
#include "SimpleHumanFactory.h"
#include "StandardHumanFactory.h"
#include "IHumanFactory.h"
#include "YellowHumanFactory.h"
#include "WhiteHumanFactory.h"
#include "BlackHumanFactory.h"
#include <iostream>
using std::cout;
using std::endl;
using std::string;
void DoFactoryMethod1()
{
cout << "----------第一批人是这样的：黄种人工厂来生产黄种人" << endl;
IHumanFactory *pHumanFactory = new CYellowHumanFactory();
IHuman *pHuman = pHumanFactory->CreateHuman();
pHuman->Cry();
pHuman->Laugh();
pHuman->Talk();
delete pHuman;
delete pHumanFactory;
}
void DoFactoryMethod2()
{
cout << "----------第二批人是这样的：白种人工厂来生产白种人" << endl;
IHumanFactory *pHumanFactory = new CWhiteHumanFactory();
IHuman *pHuman = pHumanFactory->CreateHuman();
pHuman->Cry();
pHuman->Laugh();
pHuman->Talk();
delete pHuman;
delete pHumanFactory;
}
void DoFactoryMethod3()
{
cout << "----------第一批人是这样的：黑种人工厂来生产黑种人" << endl;
IHumanFactory *pHumanFactory = new CBlackHumanFactory();
IHuman *pHuman = pHumanFactory->CreateHuman();
pHuman->Cry();
pHuman->Laugh();
pHuman->Talk();
delete pHuman;
delete pHumanFactory;
}
int _tmain(int argc, _TCHAR* argv[])
{
//工厂方法
cout << "----------工厂方法：" << endl;
DoFactoryMethod1();
DoFactoryMethod2();
DoFactoryMethod3(); _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
_CrtDumpMemoryLeaks();
return ;
}
实现方式2：所谓的简单工厂模式，通过参数传递来决定要创建哪一个具体产品。
若不需延迟实例化（将实例化放到子类中），则在Factory中增加对应的创建方法即可，如：Product* CreateConcreteProduct(int i);
若需要延迟实例化，则在抽象Factory与具体ConcreteFactory中增加相应方法，在ConcreteFactory中实现方法Product* CreateConcreteProduct(int i)
优点：无需新增产品工厂类ConcreteFactory
缺点：需要修改已有代码，存在风险
代码如下：
//Product.h
// Product.h: interface for the Product class.
//
////////////////////////////////////////////////////////////////////// #if !defined(AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_)
#define AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_ #if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000 class Product
{
public:
Product();
virtual ~Product(); }; class ConcreteProduct : public Product
{
public:
ConcreteProduct();
virtual ~ConcreteProduct(); }; class ConcreteProduct1 : public Product
{
public:
ConcreteProduct1();
virtual ~ConcreteProduct1(); }; #endif // !defined(AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_) //Product.cpp
// Product.cpp: implementation of the Product class.
//
////////////////////////////////////////////////////////////////////// #include "Product.h"
#include <iostream> using namespace std; //////////////////////////////////////////////////////////////////////
// Construction/Destruction
////////////////////////////////////////////////////////////////////// Product::Product()
{
} Product::~Product()
{
} ConcreteProduct::ConcreteProduct()
{
cout<<"ConcreteProduct..."<<endl;
} ConcreteProduct::~ConcreteProduct()
{
} ConcreteProduct1::ConcreteProduct1()
{
cout<<"ConcreteProduct1..."<<endl;
} ConcreteProduct1::~ConcreteProduct1()
{
} //Factory.h #if !defined(AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_)
#define AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_ #if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000 class Product;
class Factory
{
public:
virtual Product* CreateConcreteProduct(int i)=;
Factory();
virtual ~Factory() = ;
virtual Product* CreateProduct() = ;
virtual Product* CreateProduct1() = ;
}; class ConcreteFactory : public Factory
{
public:
ConcreteFactory();
virtual ~ConcreteFactory();
virtual Product* CreateProduct();
virtual Product* CreateProduct1();
virtual Product* CreateConcreteProduct(int i);
}; #endif // !defined(AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_) //Factory.cpp // Factory.cpp: implementation of the Factory class.
//
////////////////////////////////////////////////////////////////////// #include "Factory.h"
#include "Product.h"
#include <iostream> using namespace std; //////////////////////////////////////////////////////////////////////
// Construction/Destruction
////////////////////////////////////////////////////////////////////// Factory::Factory()
{
} Factory::~Factory()
{
} ConcreteFactory::ConcreteFactory()
{
cout<<"ConcreteFactory..."<<endl;
} ConcreteFactory::~ConcreteFactory()
{
} Product* ConcreteFactory::CreateProduct()
{
return new ConcreteProduct();
} Product* ConcreteFactory::CreateProduct1()
{
return new ConcreteProduct1();
} Product* ConcreteFactory::CreateConcreteProduct(int i)
{
Product* pProduct = NULL;
switch(i)
{
case :
pProduct = new ConcreteProduct();
break;
case :
pProduct = new ConcreteProduct1();
break;
default:
break;
}
return pProduct;
} //main.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream> using namespace std; int main()
{
Factory* pFactory = new ConcreteFactory(); Product* pProduct = pFactory->CreateProduct1(); //Product* pProduct = pFactory->CreateConcreteProduct(1);
return ;
}
若要为不同类的类提供一个创建对象的接口，要用AbstractFactory。
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。
区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。