1、简单工厂模式
定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同父类。因为在简单工厂模式中用于创建实例的方法是静态方法,所以简单工厂模式也可以称为静态工厂方法模式,是一种类创建型模式。
在简单工厂模式中,工厂类只生产一类产品,所有具体的产品的创建都集中于工厂类中,根据所传入参数的不同可以创建不同的产品对象。
简单工厂模式中的角色:
工厂角色:实现创建所有产品实例的内部逻辑;
抽象产品角色:工厂类所创建的所有对象的父类,封装了各种产品对象的公有方法;
具体产品角色:每一个具体角色都继承了抽象产品的角色,需要实现抽象产品中声明的抽象方法。
2、工厂方法模式
定义一个用于创建对象的接口,让子类决定将哪一个类实例化,它让一个类的实例化延迟到子类。它提供一个抽象工厂接口来声明抽象工厂方法,而由其子类来具体实现工厂方法,创建具体的产品对象。它是基于工厂角色和产品角色的多态性而设计的。在系统中添加新产品时,无须修改抽象工厂类,只需添加一个新工厂类和新产品类就可以了。即工厂类可以生产多类产品。相应的产品由相对应的工厂来生产。
工厂方法模式中角色:
抽象产品:定义产品的接口,是产品对象的公共父类;
具体产品:实现了抽象产品接口,某种具体的产品由专门的具体工厂创建,即具体产品与具体工厂一一对应;
抽象工厂:声明了工厂方法,用于返回一个产品。所有创建对象的工厂类都必须实现该接口。
具体工厂:是抽象工厂的子类,实现了抽象工厂中定义的工厂方法,返回的是一个具体产品类的实例。
3、抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。在它的抽象工厂类中,它声明了可以生产一族产品的方法,而每一个方法又对应一种产品。
抽象工厂模式中的角色:
抽象工厂:声明一组用于创建产品的方法,每一个方法对应一种产品;
具体工厂:实现在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族;
抽象产品:为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法;
具体产品:具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。
三种的比较,例如
要创建几种不同的图形,即圆形、方形、三角形,可以使用简单工厂模式;
如果要创建很多种不同的图形,即圆形、方形、三角形、五角形等等,使用工厂方法模式;
如果要创建各种不同颜色不同形状的图形,这时就该使用抽象工厂模式了,可以把这几种的图形的共性抽象出来。
具体例子:
简单工厂:
class SingleCore//处理器,抽象产品
{
public:
SingleCore()
{
cout<<" Constructed SingleCore "<<endl;
}
virtual ~SingleCore()//必须定义为虚析构函数
{
cout<<" Destructed SingleCore "<<endl;
}
virtual void show() = 0;//纯虚拟函数
};
class SingleCoreA : public SingleCore//A处理器,具体产品一
{
public:
SingleCoreA()
{
cout<<" Constructed SingleCore A "<<endl;
}
//由于创建的实例类型为SingleCore类型,故不调用SingleCoreB类的析构函数
~SingleCoreA()
{
cout<<" Destructed SingleCore A "<<endl;
}
void show()
{
cout<<" SingleCore A "<<endl;
}
};
class SingleCoreB : public SingleCore//B处理器,具体产品二
{
public:
SingleCoreB()
{
cout<<" Constructed SingleCore B "<<endl;
}
//由于创建的实例类型为SingleCore类型,故不调用SingleCoreB类的析构函数
~SingleCoreB()
{
cout<<" Destructed SingleCore B "<<endl;
}
void show()
{
cout<<" SingleCore B "<<endl;
}
};
class Factory//重点工厂方法类
{
public:
Factory()
{
cout<<" Constructed Factory "<<endl;
}
~Factory()
{
cout<<" Destructed Factory "<<endl;
}
//根据类型判断产生哪一个类的实例
SingleCore *CreateSingleCore(int type)
{
switch(type)
{
case 1:
return new SingleCoreA();//创建的实例类型为SingleCore
break;
case 2:
return new SingleCoreB();//创建的实例类型为SingleCore
break;
default:
cout<<"No type of the core"<<endl;
}
}
#include <iostream>
using namespace std;
#include "Simple Factory.h"
int main()
{
int type;
cout<<"Input a type of SingleCore: ";
cin>>type;
if(type == 1 || type == 2)
{
Factory *factory = new Factory();
SingleCore *singlecore = factory->CreateSingleCore(type);
singlecore->show();
delete singlecore;
delete factory;
}
else
cout<<"no creating object"<<endl;
cout<<endl;
return 0;
}
工厂方法:
#ifndef COREFACTORY_H
#define COREFACTORY_H
#include <iostream>
using namespace std;
#include "SingleCore.h"
#include "MultiCore.h"
class CoreFactory //生产处理器的工厂,抽象工厂
{
public:
CoreFactory()
{
cout<<" Construted CoreFactory "<<endl;
}
virtual ~CoreFactory()
{
cout<<" Destructed CoreFactory "<<endl;
}
//创建单核处理的工厂
virtual SingleCore* CreateSingleCore() = 0;
//创建多核处理的工厂
virtual MultiCore* CreateMultiCore() = 0;
};
class CoreFactoryA : public CoreFactory //具体工厂一
{
public:
CoreFactoryA()
{
cout<<" Construted CoreFactory A "<<endl;
}
~CoreFactoryA()
{
cout<<" Destructed CoreFactory A "<<endl;
}
SingleCore* CreateSingleCore()
{
return new SingleCoreA();//产生单核A
}
};
class CoreFactoryB : public CoreFactory //具体工厂二
{
public:
CoreFactoryB()
{
cout<<" Construted CoreFactory B "<<endl;
}
~CoreFactoryB()
{
cout<<" Destructed CoreFactory B "<<endl;
}
SingleCore* CreateSingleCore()
{
return new SingleCoreB();//产生单核A
}
};
#endif
#ifndef SINGLECORE_H
#define SINGLECORE_H
#include <iostream>
using namespace std;
class SingleCore//单核处理器,抽象产品
{
public:
SingleCore()
{
cout<<" Construted SingleCore "<<endl;
}
virtual ~SingleCore()
{
cout<<" Destructed SingleCore "<<endl;
}
virtual void show() = 0;
};
class SingleCoreA : public SingleCore //具体产品
{
public:
SingleCoreA()
{
cout<<" Construted SingleCore A "<<endl;
}
~SingleCoreA()
{
cout<<" Destructed SingleCore A "<<endl;
}
void show()
{
cout<<" Single Core A "<<endl;
}
};
class SingleCoreB : public SingleCore //具体产品
{
public:
SingleCoreB()
{
cout<<" Construted SingleCore B "<<endl;
}
~SingleCoreB()
{
cout<<" Destructed SingleCore B "<<endl;
}
void show()
{
cout<<" Single Core B "<<endl;
}
};
#endif
#include <iostream>
using namespace std;
#include "CoreFactory.h"
int main()
{
int type;
cout<<" Input type of the product: ";
cin>>type;
switch( type )
{
case 1:
{
CoreFactory * FactoryA1 = new CoreFactoryA();//创建A型工厂
SingleCore * Singlecore1 = FactoryA1->CreateSingleCore();//生产A型单核处理器
cout<<endl;
delete Singlecore1;
delete FactoryA1;
break;
}
case 2:
{
CoreFactory * FactoryB1 = new CoreFactoryB();//创建B型工厂
SingleCore * Singlecore2 = FactoryB1->CreateSingleCore();//生产B型单核处理器
cout<<endl;
delete Singlecore2;
delete FactoryB1;
break;
}
default:
cout<<" No this type of product "<<endl;
}
cout<<endl;
return 0;
}
抽象工厂:
#ifndef ABSTRACT FACTORY_H
#define ABSTRACT FACTORY_H
#include <iostream>
using namespace std;
#include "IDepartment.h"
#include "IUser.h"
class Factory//抽象工厂
//包括Access工厂和Department工厂
{
public:
Factory()
{
cout<<" Constructed Factory "<<endl;
}
virtual ~Factory()
{
cout<<" Destruvted Factory "<<endl;
}
virtual IUser* CreateUser() = 0;
virtual IDepartment* CreateDepartment() = 0;
};
class AccessFactory : public Factory//Access工厂,具体工厂一
{
public:
AccessFactory()
{
cout<<" Constructed AccessFactory "<<endl;
}
virtual ~AccessFactory()
{
cout<<" Destructed AccessFactory "<<endl;
}
virtual IUser* CreateUser()
{
return new AccessUser();//创建Access用户
}
virtual IDepartment* CreateDepartment()
{
return new AccessDepartment();//创建Access部门
}
};
class SqlFactory : public Factory//Sql工厂,具体工厂二
{
public:
SqlFactory()
{
cout<<" Constructed SqlFactory "<<endl;
}
virtual ~SqlFactory()
{
cout<<" Destructed SqlFactory "<<endl;
}
virtual IUser* CreateUser()
{
return new SqlUser();//创建Sql用户
}
virtual IDepartment* CreateDepartment()
{
return new SqlDepartment();//创建Sql部门
}
};
#endif
#ifndef IDEPARTMENT_H
#define IDEPARTMENT_H
#include <iostream>
using namespace std;
class IDepartment//部门抽象接口,抽象产品一
//部门包括Access部门和Sql部门
{
public:
IDepartment()
{
cout<<" Constructed IDepartment "<<endl;
}
virtual ~IDepartment()
{
cout<<" Destructed IDepartment "<<endl;
}
virtual void GetDepartment() = 0;
virtual void InsertDepartment() = 0;
};
class AccessDepartment : public IDepartment//Access部门
{
public:
AccessDepartment()
{
cout<<" Constructed AccessDepartment "<<endl;
}
virtual ~AccessDepartment()
{
cout<<" Destructed AccessDepartment "<<endl;
}
virtual void GetDepartment()
{
cout<<" Access GetDepartment "<<endl;
}
virtual void InsertDepartment()
{
cout<<" Access InsertDepartment "<<endl;
}
};
class SqlDepartment : public IDepartment//Sql部门
{
public:
SqlDepartment()
{
cout<<" Constructed SqlDepartment "<<endl;
}
virtual ~SqlDepartment()
{
cout<<" Destructed SqlDepartment "<<endl;
}
virtual void GetDepartment()
{
cout<<" Sql GetDepartment "<<endl;
}
virtual void InsertDepartment()
{
cout<<" Sql InsertDepartment "<<endl;
}
};
#endif
#ifndef IUSER_H
#define IUSER_H
#include <iostream>
using namespace std;
class IUser//用户抽象接口,用于产生不同的用户,抽象产品二
//它包括Access用户和Sql用户
{
public:
IUser()
{
cout<<" Constructed IUser "<<endl;
}
virtual ~IUser()
{
cout<<" Destructed IUser "<<endl;
}
virtual void GetUser() = 0;//纯虚拟函数
virtual void InsertUser() = 0;
};
class AccessUser : public IUser//Access用户
{
public:
AccessUser()
{
cout<<" Constructed AccessUser "<<endl;
}
virtual ~AccessUser()
{
cout<<" Destructed AccessUser "<<endl;
}
virtual void GetUser()
{
cout<<" Access GetUser "<<endl;
}
virtual void InsertUser()
{
cout<<" Access InsertUser "<<endl;
}
};
class SqlUser : public IUser//SQL用户
{
public:
SqlUser()
{
cout<<" Constructed SqlUser "<<endl;
}
virtual ~SqlUser()
{
cout<<" Destructed SqlUser "<<endl;
}
virtual void GetUser()
{
cout<<" Sql GetUser "<<endl;
}
virtual void InsertUser()
{
cout<<" Sql InsertUser "<<endl;
}
};
#endif
#include "Abstract Factory.h"
int main()
{
Factory* factory = new SqlFactory();//新建一个Sql工厂
IUser* user = factory->CreateUser();//创建Sql用户
IDepartment* depart = factory->CreateDepartment();//创建Sql部门
cout<<endl;
user->GetUser();
depart->GetDepartment();
cout<<endl;
delete depart;
cout<<endl;
delete user;
cout<<endl;
delete factory;
cout<<endl;
return 0;
}