23 DesignPatterns学习笔记：C++语言实现 --- 1.2 AbstractFactory

23 DesignPatterns学习笔记：C++语言实现 --- 1.2 AbstractFactory

 2016-07-21

（www.cnblogs.com/icmzn）

---

 

模式理解

 

 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 CAbsFactory
{
public:
    virtual CAbsProductA* getProductA() = 0;
    virtual CAbsProductB* getProductB() = 0;
};

//1类型的不同产品
class CFactory1 : public CAbsFactory
{
public:
    //可以维护一组或相互依赖的类
    CAbsProductA* getProductA();
    CAbsProductB* getProductB();
};

//2类型的不同产品
class CFactory2 : public CAbsFactory
{
public:
    //可以维护一组或相互依赖的类
    CAbsProductA* getProductA();
    CAbsProductB* getProductB();
};

#endif

factory.cpp

#include "Factory.h"

CAbsProductA* CFactory1::getProductA()
{
    return new CProductA1();
}
CAbsProductB* CFactory1::getProductB()
{
    return new CProductB1();
}

//相互依赖的类组合在一个类中
CAbsProductA* CFactory2::getProductA()
{
    return new CProductA2();
}
CAbsProductB* CFactory2::getProductB()
{
    return new CProductB2();
}

product.h

#pragma once
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

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

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

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


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

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


//具体派生类A
class CProductB1 :public CAbsProductB
{
public:
    CProductB1();
public:
    ~CProductB1();
public:
    void CommonMethodB() override;

};
class CProductB2 :public CAbsProductB
{
public:
    CProductB2();
public:
    ~CProductB2();
public:
    void CommonMethodB() override;


};

#endif

product.cpp

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

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

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

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


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

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

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

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

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

void CProductB1::CommonMethodB()
{
    cout << "CProductB1 业务逻辑" << endl;
}


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

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

void CProductB2::CommonMethodB()
{
    cout << "CProductB2 业务逻辑" << endl;
}


//dafd

 

---

模板应用

 main.cpp

// AbstractFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "Factory.h"

int _tmain(int argc, _TCHAR* argv[])
{
    //抽象工厂，关键通过一个相互关联的类组合在一起，完成不同工厂类的管理
    CAbsFactory *pFactroy = nullptr;
    CAbsProductA *pProductA = nullptr;
    CAbsProductB *pProductB = nullptr;

    pFactroy = new CFactory2();
    pProductA = pFactroy->getProductA();
    pProductB = pFactroy->getProductB();
    pProductA->CommonMethodA();
    pProductB->CommonMethodB();
    delete pFactroy;
    //在创建1类的产品族时，只创建了一个对象,便于维护
    //曾佳产品族等级扩展容易，增加新产品困难。
    pFactroy = new CFactory1();
    pProductA = pFactroy->getProductA();
    pProductB = pFactroy->getProductB();
    pProductA->CommonMethodA();
    pProductB->CommonMethodB();
    delete pFactroy;

    system("pause");
    return 0;
}

 

输出展示