设计模式之抽象工厂模式

一、概述

###抽象工厂模式，以一个鞋业代理工厂为例（可代理生产Nike，Adidas的鞋子)
ConcreteFactory1, ConcreteFactory2 这里对实例工厂的分类，每一个实例工厂对应一可以看做是生产同一系列（品种）下的产品，
                                    举例：前者代表Nike鞋工厂类，后者代表Adidas鞋工厂类。
ConcreteProductA, ConcreteProductB 这里对实例产品的分类，每一个实例产品可以看做是不同系列的产品集合，
                                    如：分别代表各式鞋子，分别代表布鞋（派生出nike布鞋，adidas布鞋）和皮鞋（派生出nike皮鞋，adidas皮鞋）
1，2，3......代表品种（系列）：如NIKE, ADIDAS
A，B，C......代表产品，其派生类可延伸出各种品种（系列）下的产品，如布鞋，皮鞋

说明：
工厂模式下，对管理的产品没有做进一步的分类，获取所有产品的返回值都是它们的虚基类，只能看做是对某一类类的操作。
而抽象工厂模式，则对产品进行规划的基础上，又再次细分成产品系列；对工厂类也做了扩展，返回不再是产品的公共虚基类，而是产品所在系列的基类。
这正如一家鞋业代理工厂要生产鞋子一样，如果它代理10家的品牌，这10家品牌都从一个码头出货，哇咔咔，出货码头人来人往，货来货往，好像有点堵哦。
而抽象工厂将产品划分到系列，为每个系列定义接口，这样一来，每个品牌的鞋子都有自己的通道来接货，各品牌之间相互独立，码头也变得井然有序了。


###工厂模式
ConcreteFactory1 ：生产(new)多个产品，返回产品的虚基类。
ConcreteProductA ：最终产品，基于虚基类

###抽象工厂模式
ConcreteFactory1 ： 生产（new)本系列的多个产品，而且同款产品会存在多个系列，
ConcreteProductA ： 中间产品，上基于虚基类，下派生不同系列下的同款产品

优点：新增系列产品，只需要新增一个工厂即可。
缺点：新增某一新产品时，就变得困难了

总结：
    抽象工厂不仅对产品类做了规划，同时也对工厂类做了改善。具体表现为：对产品的规划变成了3层结构：产品虚基类-产品系列子类-产品子类；工厂仍保持2层结构，但在第2层做了扩展：工厂虚基类-创建产品系列子类

    我们前面说过，标准工厂的做法就是定义一个创建所有产品的公共接口，供工厂派生类使用。
    当产品过多时，使用标准工厂就有些力不从心，因为这些产品都来自于同一个接口，是非常不利于管理的。

二、类图

三、代码

IProduct.h, IProduct.cpp (见简单工厂模式）

ConcreteProductA.h， ConcreteProductA.cpp (同上）

ConcreteProductB.h, ConcreteProductB.cpp (同上）

ConcreteProductA1.h  //产品A： 系列1下的产品A

#pragma once
#include "ConcreteProductA.h"

class CConcreteProductA1 :public CConcreteProductA
{
public:
	CConcreteProductA1();
	virtual ~CConcreteProductA1();

public:
	virtual void Function();

};

 ConcreteProductA1.cpp

#include "ConcreteProductA1.h"

CConcreteProductA1::CConcreteProductA1()
{
	cout<<__FUNCTION__<<endl;
}

CConcreteProductA1::~CConcreteProductA1()
{
	cout<<__FUNCTION__<<endl;
}

void CConcreteProductA1::Function()
{
	cout<<__FUNCTION__<<endl;
}

ConcreteProductA2.h

#pragma once
#include "ConcreteProductA.h"

class CConcreteProductA2 :public CConcreteProductA
{
public:
	CConcreteProductA2();
	virtual ~CConcreteProductA2();

public:
	virtual void Function();

};

ConcreteProductA2.cpp

#include "ConcreteProductA2.h"

CConcreteProductA2::CConcreteProductA2()
{
	cout<<__FUNCTION__<<endl;
}

CConcreteProductA2::~CConcreteProductA2()
{
	cout<<__FUNCTION__<<endl;
}

void CConcreteProductA2::Function()
{
	cout<<__FUNCTION__<<endl;
}

ConcreteProductB1.h

#pragma once
#include "ConcreteProductB.h"

class CConcreteProductB1 :public CConcreteProductB
{
public:
	CConcreteProductB1();
	virtual ~CConcreteProductB1();

public:
	virtual void Function();

};

ConcreteProductB1.cpp

#include "ConcreteProductB1.h"

CConcreteProductB1::CConcreteProductB1()
{
	cout<<__FUNCTION__<<endl;
}

CConcreteProductB1::~CConcreteProductB1()
{
	cout<<__FUNCTION__<<endl;
}

void CConcreteProductB1::Function()
{
	cout<<__FUNCTION__<<endl;
}

ConcreteProductB2.h

#pragma once
#include "ConcreteProductB.h"

class CConcreteProductB2 :public CConcreteProductB
{
public:
	CConcreteProductB2();
	virtual ~CConcreteProductB2();

public:
	virtual void Function();

};

ConcreteProductB2.cpp

#include "ConcreteProductB2.h"

CConcreteProductB2::CConcreteProductB2()
{
	cout<<__FUNCTION__<<endl;
}

CConcreteProductB2::~CConcreteProductB2()
{
	cout<<__FUNCTION__<<endl;
}

void CConcreteProductB2::Function()
{
	cout<<__FUNCTION__<<endl;
}

IAbstractFactory.h

#pragma once

//抽象工厂类要创建多个系列产品，所以要#include产品系列的类进来
#include "ConcreteProductA.h"
#include "ConcreteProductB.h"


class IAbstractFactory
{
public:
	IAbstractFactory();
	virtual ~IAbstractFactory();

public:
	virtual CConcreteProductA *CreateA() = 0;
	virtual CConcreteProductB *CreateB() = 0;
};

IAbstractFactory.cpp

#include "IAbstractFactory.h"

IAbstractFactory::IAbstractFactory()
{

}

IAbstractFactory::~IAbstractFactory()
{

}

ConcreteAbsFactory1.h

#pragma once

#include "IAbstractFactory.h" 

//应该放在cpp文件里面
#include "ConcreteProductA1.h"
#include "ConcreteProductB1.h"
//工厂派生类1：创建某一系列下的产品，
class CConcreteAbsFactory1 :public IAbstractFactory
{
public:
	CConcreteAbsFactory1();
	virtual ~CConcreteAbsFactory1();

public:
	virtual CConcreteProductA *CreateA();
	virtual CConcreteProductB *CreateB();
};

ConcreteAbsFactory1.cpp

#include "ConcreteAbsFactory1.h"

CConcreteAbsFactory1::CConcreteAbsFactory1()
{

}

CConcreteAbsFactory1::~CConcreteAbsFactory1()
{

}


CConcreteProductA *CConcreteAbsFactory1::CreateA()
{
	return new CConcreteProductA1();
}

CConcreteProductB *CConcreteAbsFactory1::CreateB()
{
	return new CConcreteProductB1();
}

ConcreteAbsFactory2.h

#pragma once

#include "IAbstractFactory.h" 

//应该放在cpp文件里面
#include "ConcreteProductA2.h"
#include "ConcreteProductB2.h"
//工厂派生类2：创建某一系列下的产品，
class CConcreteAbsFactory2 :public IAbstractFactory
{
public:
	CConcreteAbsFactory2();
	virtual ~CConcreteAbsFactory2();

public:
	virtual CConcreteProductA *CreateA();
	virtual CConcreteProductB *CreateB();
};

ConcreteAbsFactory2.cpp

#include "ConcreteAbsFactory2.h"

CConcreteAbsFactory2::CConcreteAbsFactory2()
{

}

CConcreteAbsFactory2::~CConcreteAbsFactory2()
{

}


CConcreteProductA *CConcreteAbsFactory2::CreateA()
{
	return new CConcreteProductA2();
}

CConcreteProductB *CConcreteAbsFactory2::CreateB()
{
	return new CConcreteProductB2();
}

 main.cpp

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

int main()
{
	cout<<"[New ConcreteAbsFactory1]:"<<endl;
	IAbstractFactory *absfac1 = new CConcreteAbsFactory1();
	cout<<"[Create Products of 1 serial]:"<<endl; 
	absfac1->CreateA();
	absfac1->CreateB();

	cout<<"[New ConcreteAbsFactory2]:"<<endl;
	IAbstractFactory *absfac2 = new CConcreteAbsFactory2();
	cout<<"[Create Products of 2 serial]:"<<endl; 
	absfac2->CreateA();
	absfac2->CreateB();

	return 0;
}

四、运行结果

[New ConcreteAbsFactory1]:
[Create Products of 1 serial]:
CConcreteProductA::CConcreteProductA
CConcreteProductA1::CConcreteProductA1
CConcreteProductB::CConcreteProductB
CConcreteProductB1::CConcreteProductB1
[New ConcreteAbsFactory2]:
[Create Products of 2 serial]:
CConcreteProductA::CConcreteProductA
CConcreteProductA2::CConcreteProductA2
CConcreteProductB::CConcreteProductB
CConcreteProductB2::CConcreteProductB2
请按任意键继续. . .