由于最近压在身上的项目已经干完,在目前有空闲时间的状况下,开始了学习设计模式之旅.下面会根据自己学习过程中的理解,写些文章和测试代码大家一起学习讨论.
在所有已知的各种模式中，最重要的和应用范围最广泛的模式应该是属于工厂模式了。尤其在很多的框架性编程里面使用比较的多,见过工作的系统中或多或少都有一些工厂模式应用的场景.
闲话少说上菜:
第一类工厂模式(Template Method)
根据我查阅的很多技术类文章表示, Template Method严格讲不能算是工厂模式,但是从理解它的本质跟工厂模式的特点进行比较的时候发现他们的本质作用基本一致,所以也可以看作它是工厂模式的一种形式,只是比较特殊而已.类关系图(本人画类关系图比较的简单,务见谅!):
该模式简单测试代码实现:
//Factory.h
/**
* 静态工厂方法模式的实现
* 工厂抽象类
* @Factory1 具体派生的子类
* @Factory2 具体派生的子类
* @author wangfengzhongguo@126.com
**/
#ifndef __FACTORY_H__
#define __FACTORY_H__
#include
using namespace std;
class Factory {
public:
Factory();
~Factory();
virtual void display()=0;
static Factory* getInstance(const string & type);
};
#endif
//Factory.cpp
#include "Factory.h"
#include "Factory1.h"
#include "Factory2.h"
#include
Factory* Factory::getInstance(const string & type)
{
Factory * fact = NULL;
if (type == "factory1")
{
fact = new Factory1();
}
else
{
fact = new Factory2();
}
return fact;
}
Factory::~Factory(){}
Factory::Factory(){}
//Factory1.h
/**
* 静态工厂方法具体派生类
**/
#ifndef __FACTORY1_H__
#define __FACTORY1_H__
#include "Factory.h"
using namespace std;
class Factory1 : public Factory
{
public:
Factory1();
~Factory1();
virtual void display();
};
#endif
//Factory1.cpp
#include "Factory1.h"
Factory1::Factory1()
{
cout<<"Factory1"<
}
Factory1::~Factory1()
{
}
void Factory1::display()
{
cout<<"It's me!Factory1!"<
}
//Factory2.h
/**
* 静态工厂方法具体派生类
**/
#ifndef __FACTORY2_H__
#define __FACTORY2_H__
#include "Factory.h"
class Factory2 : public Factory
{
public:
Factory2();
~Factory2();
virtual void display();
};
#endif
//Factory2.cpp
#include "Factory2.h"
Factory2::Factory2()
{
cout<<"Factory2"<
}
Factory2::~Factory2()
{
}
void Factory2::display()
{
cout<<"It's me!Factory2!"<
}
//testFactory.cpp
#include "Factory.h"
int main()
{
Factory * pfsys= NULL;
pfsys=Factory::getInstance("factory1");
pfsys->display();
pfsys=Factory::getInstance("factory2");
pfsys->display();
return 0;
}
//makefile
OBJECTS=Factory1.o Factory.o Factory2.o testFactory.o
CC=g++
testFactory: $(OBJECTS)
$(CC) $(OBJECTS) -o testFactory
Factory1.o: Factory1.h
Factory.o: Factory.h
Factory2.o: Factory2.h
testFactory.o:
clean:
rm -f testFactory core $(OBJECTS)
该类设计模式一开始在参与项目的组件层设计里面接触到,当时对此实现表示出了怀疑,因为它看上去并不像工厂模式的实现方式,经过查阅很多的技术资料,以及写了测试程序后才发现这种模式的应用场合以及这样设计的用意.
在实际项目的应用中如果目标对象的继承体系比较简单、固定，功能比较单一，可能在未来发生的变化是比较容易预期到的，则可以考虑使用这种方法。比如FTP传输文件,由于需要传输不同协议的文件,而这些协议文件的增加有限,并且变动不大的情况下就是可以采用这种设计的方式!!
第二类工厂模式(简单工厂模式)
一般是一个工厂类对应多个具体产品类，通过外界向工厂传递的参数来判断创建某一个具体的产品类对象。闲话少说,看类关系图:
测试代码:
//Factory.h
/**
* @简单工厂模式的实现
* @工厂类,负责根据传入的类型,创建相应产品的对象
* @author wangfengzhongguo@126.com
**/
#ifndef FACTORY_H
#define FACTROY_H
#include
#include "Product.h"
using namespace std;
class Factory
{
public:
Factory();
~Factory();
static Product* getInstance(const string &type);
};
#endif
//Factory.cpp
#include "Factory.h"
#include "Product1.h"
#include "Product2.h"
Product *Factory::getInstance(const string &type)
{
Product *proc = NULL;
if(type == "product1")
proc = new Product1();
else if(type == "product2")
proc = new Product2();
return proc;
}
Factory::~Factory(){}
Factory::Factory(){}
//Product.h
/**
* @产品抽象类
* @author wangfengzhongguo@126.com
**/
#ifndef PRODUCT_H
#define PRODUCT_H
#include
using namespace std;
class Product
{
public:
virtual void display()=0;
};
#endif
//Product1.h
/**
* @具体产品类
* @author wangfengzhongguo@126.com
**/
#ifndef PRODUCT1_H
#define PRODUCT1_H
#include "Product.h"
class Product1: public Product
{
public:
Product1();
~Product1();
virtual void display();
};
#endif
//Product1.cpp
#include "Product1.h"
Product1::Product1()
{
cout<<"Product1"<
}
Product1::~Product1()
{
}
void Product1::display()
{
cout<<"It's me!Product1!"<
}
//Product2.h
/**
* @具体产品类
* @author wangfengzhongguo@126.com
**/
#ifndef PRODUCT2_H
#define PRODUCT2_H
#include "Product.h"
class Product2: public Product
{
public:
Product2();
~Product2();
virtual void display();
};
#endif
//Product2.cpp
#include "Product2.h"
Product2::Product2()
{
cout<<"Product2"<
}
Product2::~Product2()
{
}
void Product2::display()
{
cout<<"It's me!Product2!"<
}
//testFactory.cpp
#include "Factory.h"
int main()
{
Product * pfsys= NULL;
pfsys=Factory::getInstance("product1");
pfsys->display();
pfsys=Factory::getInstance("product2");
pfsys->display();
return 0;
}
//makefile
OBJECTS=Product1.o Factory.o Product2.o testFactory.o
CC=g++
testFactory: $(OBJECTS)
$(CC) $(OBJECTS) -o testFactory
Product1.o: Product1.h
Factory.o: Factory.h Product.h
Product2.o: Product2.h
testFactory.o:
clean:
rm -f testFactory core $(OBJECTS)
简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
作用:
从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当产品增加了同类的一个的时候，只要符合抽象产品制定的要求，那么只要通知工厂类做修改就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的!! 但是工厂部分好像不太理想，因为每增加一个同类产品，都要在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。那么就是随着新产品的加入,工厂类都是要被动的做修改的.那么就有了下面这类工厂模式的演进.
第三类工厂模式(工厂方法)
设计产品抽象类和工厂抽象类,产品对应的具体类的对象的创建由我们工厂抽象类的具体类一一对应实现.这一类的设计一般产品只可以是一类的.如类关系图:
每一个工厂的具体类负责一个类别的产品具体的创建工作,这类实现的好处就是每次增加该类别的产品的时候只要对应的创建工厂的具体类负责就可以了,这种模式适合一类产品快速变化的需求!!
工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。
每次增加对应的新产品就派生一个工厂类来负责一一对应!
测试代码可以根据类关系图自己写一个,由于时间关系,这里就暂时不写了,以后写好放上来.
第四类工厂模式(抽象工厂模式)
当我们的产品需要上升到两类甚至多类的时候,上面那种模式已经不能满足了,那么自然就演进到了抽象工厂模式了.
类关系图:
可以说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
