23 DesignPatterns学习笔记：C++语言实现 --- 1.1 Factory

23 DesignPatterns学习笔记：C++语言实现 --- 1.1 Factory

 2016-07-18 13:03:43

---

 

模式理解

1. Factory method 定义
    一个创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类实例化延迟到子类。

2. factory method 设计模式优点：
（1）工厂方法是典型的解构框架，高层模块只需要知道产品的“抽象类”，其他的实现类都不需要关心（高层与底层特例解耦）；
高层只依赖产品的抽象类。
（2）屏蔽产品特例类。产品的实例化是由工厂负责的，如使用使用JDBC连接数据库，数据库从MySQL切换到oracle，
只需要改动的地方是棋换一下“驱动名称”，这是factory模式灵活性的直接案例。
（3）扩展性非常优秀。对于后续变化的产品，只需要添加产品类，修改一下工厂方法即可。
（4）良好的封装。上层的调用只需要特定的（约束性）的特征，即可封装同类产品的创建过程，降低模块间的耦合

3.factory method 模式 适用场景：
（1）factory方法 是 一类对象new 的良好替代品。需要考虑是否增加一个工厂类管理的，增加代码的复杂度。
（2）需要灵活地额可扩展的方法，可以考虑factory方法。

4. factory method 模式的扩展
（1）缩小为“简单工厂方法”模式，或“静态工厂方法”模式
    如果此模块只需要一个工厂方法，则没有必要把他实例处理new 出来，只需要使用类的静态成员方法即可
Factory::getProduct(),这样简化了工厂类的创建。
    调用者也变得简单了，该模式是factory method 方法的弱化， 成为Simple Factory Method，
（2）升级为“多工厂类“
    如果初始化一个类会相当复杂，且使代码结构不清晰，所有的类创建都放在一个factory method 方法中，方法会变得巨大
    可以为每一个类的创建都定义一个factory，这样结构清晰简单。或者再抽象出工厂基类，作为协调类，封装子类工厂。
但是因为每一个类对应一个工厂类，维护性变得差，增加了扩展的难度。
（3）延迟初始化，
    以factory method 模式为基础，通过增加map类型成员，容纳不同类型的初始化对象。通过map缓冲，对初始化对象缓冲保留，下次直接取出。
    还可以通过map控制相应类的初始化数量。

---

 

程序实现（C++）

 Factory.h

#pragma once
#ifndef _FACTORY_H_
#define _FACTORY_H_
#include "Product.h"

//工厂模式
class CFactory
{
public:
    //CFactory();
    //~CFactory();
    //可以维护一类产品的创建
    static CAbsProductA* getProduct(ProductAEnum productAType);
};

#endif

factory.cpp

#include "Factory.h"

CAbsProductA* CFactory::getProduct(ProductAEnum type)
{
    CAbsProductA *pProdcutA = nullptr;
    switch (type)
    {
    case eProductA1:
        pProdcutA = new CProductA1();
        break;
    case eProductA2:
        pProdcutA = new CProductA2();
        break;
    }
    if (!pProdcutA)
        throw "CProdutA constructed fail!!!";
    return pProdcutA;
}

Product.h

#pragma once
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

//抽象产品
class CAbsProductA
{
protected://保护构造接口,且抽象类不能实例化
    CAbsProductA();
public:
    ~CAbsProductA();
public:
    //虚函数
    virtual void CommonMethod1() = 0;
};
enum ProductAEnum {eProductA1, eProductA2 };

//具体派生类A
class CProductA1 :public CAbsProductA
{
public:
    CProductA1();
public:
    ~CProductA1();
public:
    void CommonMethod1();

};
class CProductA2 :public CAbsProductA
{
public:
    CProductA2();
public:
    ~CProductA2();
public:
    void CommonMethod1();

};
//具体派生类B...
#endif

Product.cpp

#include "Product.h"
#include <iostream>
using namespace std;

CAbsProductA::CAbsProductA()
{

}

CAbsProductA::~CAbsProductA()
{
}

CProductA1::CProductA1()
{
    cout << "CProductA1 构建" << endl;
}

CProductA1::~CProductA1()
{
    cout << "CProductA1 析构" << endl;
}

void CProductA1::CommonMethod1()
{
    cout << "CProductA1 业务逻辑" << endl;
}


CProductA2::CProductA2()
{
    cout << "CProductA2 构建" << endl;
}

CProductA2::~CProductA2()
{
    cout << "CProductA2 析构" << endl;
}

void CProductA2::CommonMethod1()
{
    cout << "CProductA2 业务逻辑" << endl;
}

main.cpp

#include "stdafx.h"
#include "Factory.h"
using namespace std;
#include <iostream>
int _tmain(int argc, _TCHAR* argv[])
{
    //instream_iteratork
    CFactory* pFactory = new CFactory();
    CAbsProductA* pProductA = pFactory->getProduct(eProductA1);
    pProductA->CommonMethod1();
    pProductA = pFactory->getProduct(eProductA2);
    pProductA->CommonMethod1();

    //简单工厂方法模式
    pProductA = CFactory::getProduct(eProductA1);
    pProductA->CommonMethod1();
    pProductA = CFactory::getProduct(eProductA2);
    pProductA->CommonMethod1();

    system("pause");
    return 0;
}

 

---

 

输出展示