简单工厂模式
定义一个工厂类,它可以根据不同的参数返回不同的实例,被创建的实例通常都有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态方法,所以简单工厂模式又被称为静态工厂模式。
上图解释如下:
Factory 工厂类,是简单工厂模式的核心,负责所有产品实例的逻辑,工厂类可以被外界外界直接调用,创建所需的产品对象,工厂类提供静态工厂方法,返回的类型为抽象产品类型Product。
Product 抽象产品角色,是工厂类创建的所有的对象的父类。封装了各种产品对象的共有方法。他的引入将提高系统的灵活性,使得在工厂类中只需要定义一个通用的工厂方法,以为所有创建的具体产品对象都是其子类的对象。
ConcreteProduct 它是简单工厂模式的创建目标,所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了产品角色,需要实现抽象产品中声明的抽象方法。
C++实现一个简单工厂模式:
AbstractProduct.h
#include <stdio.h>
class AbstractProduct{
public:
AbstractProduct();
virtual ~AbstractProduct();
virtual void operation() = 0;
};
class ProductA:public AbstractProduct
{
public:
ProductA();
virtual ~ProductA();
void operation();
};
class ProductB:public AbstractProduct
{
public:
ProductB();
virtual ~ProductB();
void operation();
};
AbstractProduct.cpp
#include "AbstractProduct.h"
AbstractProduct::AbstractProduct(){}
AbstractProduct::~AbstractProduct(){}
ProductA::ProductA(){}
ProductA::~ProductA(){}
void ProductA::operation(){
printf("hello productA\n");
}
ProductB::ProductB(){}
ProductB::~ProductB(){}
void ProductB::operation(){
printf("hello productB\n");
}
SimpleFactory.h
#include <stdio.h>
#include "AbstractProduct.h"
class AbstractFactory
{
public:
AbstractFactory();
virtual ~AbstractFactory();
virtual AbstractProduct * createProduct(int type) = 0;
};
class SimpleFactory:public AbstractFactory
{
public:
SimpleFactory();
~SimpleFactory();
AbstractProduct * createProduct(int type);
};
SimpleFactory.cpp
#include "SimpleFactory.h"
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
SimpleFactory::SimpleFactory(){}
SimpleFactory::~SimpleFactory(){}
AbstractProduct * SimpleFactory::createProduct(int type)
{
AbstractProduct * temp = NULL;
if(1 == type){
temp = new ProductA();
}else if(2 == type) {
temp = new ProductB();
}
return temp;
}
client.cpp
int main()
{
AbstractFactory * factory = new SimpleFactory();
AbstractProduct * product1 = factory->createProduct(1);
product1->operation();
delete product1;
product1 = NULL;
AbstractProduct * product2 = factory->createProduct(2);
product2->operation();
delete product2;
product2 = NULL;
system("pause");
}
运行结果:
可以看出简单工厂模式的优点:
1 隐藏了对象创建的细节,将产品的实例化推迟到子类中实现。
2 客户端不需要知道所创建的具体的类的名称,只提供相应的参数就可以了
缺点:
1 工厂类集中了所有产品的创建逻辑,职责过重。
2 每添加一个产品子类,都必须在工厂类中添加一个判断分支,这违背了开放-封闭原则。
3 要求产品子类的类型差不多,使用的方法名都相同,如果类比较多,而所有的类又必须要添加一种方法,则会是非常麻烦的事情。
对该模式的改进见下篇文章工厂方法模式,又称工厂模式。