设计模式学习笔记DAY02-抽象工厂模式(AbstractFactory)

二、抽象工厂模式（Abstract Factory）
1.定义
        提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
2.抽象工厂模式与工厂方法模式的区别
        为了更好的理解工厂模式非常有必要将抽象工厂模式与工厂方法模式进行对比。工厂方法模式是一种极端情况的抽象工厂模式，它是对应与一个类（一个类的对象），而抽象工厂模式可以看成是工厂方法模式的一种推广，是针对于一系列类（多个类的对象）。
    工厂方法模式：一个抽象产品类，然后在此基础上派生出多个具体产品类。一个抽象工厂类，然后派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。  
    抽象工厂模式：多个抽象产品类，然后每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，然后派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。
    例子：还是以CPU为例现在市场上最热的两个CPU厂商为Inter和AMD，它们都各自有各自的单核、双核CPU，假设现在有两家代加工的工厂三星和富士康，它们都同时给Inter和AMD加工不同型号的CPU，现在需要拿出所有的产品测试一下。

//AbstractFactory.h
#pragma once

typedef enum
{
	SINGLE_CORE = 0,
	DOUBLE_CORE
}CORE_TYPE;

class InterCPU
{
	public:
		virtual void Run() = 0;
};

class InterSingleCore :public InterCPU
{
	public:
		void Run();
};

class InterDoubleCore :public InterCPU
{
	public:
		void Run();
};

class AMDCPU
{
public:
	virtual void Run() = 0;
};

class AMDSingleCore :public AMDCPU
{
public:
	void Run();
};

class AMDDoubleCore :public AMDCPU
{
public:
	void Run();
};

class CPUFactory
{
	public:
		virtual InterCPU* CreateInterCPU(CORE_TYPE eType) = 0;
		virtual AMDCPU* CreateAMDCPU(CORE_TYPE eType) = 0;
};
class SamsungFactory :public CPUFactory
{
	public:
		InterCPU* CreateInterCPU(CORE_TYPE eType);
		AMDCPU* CreateAMDCPU(CORE_TYPE eType);
};
class FoxconnFactory :public CPUFactory
{
	public:
		InterCPU* CreateInterCPU(CORE_TYPE eType);
		AMDCPU* CreateAMDCPU(CORE_TYPE eType);
};

//AbstractFactory.cpp
#include "StdAfx.h"
#include "Factory.h"
#include <iostream>
using namespace std;

void InterSingleCore::Run()
{
	cout<<"InterSingleCoreRun"<<endl;
}

void InterDoubleCore::Run()
{
	cout<<"InterDoubleCoreRun"<<endl;
}

void AMDSingleCore::Run()
{
	cout<<"AMDSingleCoreRun"<<endl;
}

void AMDDoubleCore::Run()
{
	cout<<"AMDDoubleCoreRun"<<endl;
}

AMDCPU* SamsungFactory::CreateAMDCPU(CORE_TYPE eType)
{
	switch (eType)
	{
		case SINGLE_CORE:
			return new AMDSingleCore(); 
			break;
		case DOUBLE_CORE:
			return new AMDDoubleCore();
			break;
		default:
			return new AMDDoubleCore();
			break;
	}
}

InterCPU* SamsungFactory::CreateInterCPU(CORE_TYPE eType)
{
	switch (eType)
	{
		case SINGLE_CORE:
			return new InterSingleCore(); 
			break;
		case DOUBLE_CORE:
			return new InterDoubleCore();
			break;
		default:
			return new InterDoubleCore();
			break;
	}	
}

AMDCPU* FoxconnFactory::CreateAMDCPU(CORE_TYPE eType)
{
	switch (eType)
	{
		case SINGLE_CORE:
			return new AMDSingleCore(); 
			break;
		case DOUBLE_CORE:
			return new AMDDoubleCore();
			break;
		default:
			return new AMDDoubleCore();
			break;
	}
}

InterCPU* FoxconnFactory::CreateInterCPU(CORE_TYPE eType)
{
	switch (eType)
	{
		case SINGLE_CORE:
			return new InterSingleCore(); 
			break;
		case DOUBLE_CORE:
			return new InterDoubleCore();
			break;
		default:
			return new InterDoubleCore();
			break;
	}
}

//main.cpp
#include "stdafx.h"
#include "Factory.h"

int _tmain(int argc, _TCHAR* argv[])
{
	CPUFactory *pSamFac = new SamsungFactory();
	AMDCPU *pAMDCPU = pSamFac->CreateAMDCPU(SINGLE_CORE);
	pAMDCPU->Run();

	pAMDCPU = pSamFac->CreateAMDCPU(DOUBLE_CORE);
	pAMDCPU->Run();

	InterCPU* pInterCPU;
	pInterCPU = pSamFac->CreateInterCPU(SINGLE_CORE);
	pInterCPU->Run();

	pInterCPU = pSamFac->CreateInterCPU(DOUBLE_CORE);
	pInterCPU->Run();

	CPUFactory *pFoxFac = new FoxconnFactory();
	pAMDCPU = pFoxFac->CreateAMDCPU(SINGLE_CORE);
	pAMDCPU->Run();

	pAMDCPU = pFoxFac->CreateAMDCPU(DOUBLE_CORE);
	pAMDCPU->Run();

	pInterCPU = pFoxFac->CreateInterCPU(SINGLE_CORE);
	pInterCPU->Run();
	
	pInterCPU =	pFoxFac->CreateInterCPU(DOUBLE_CORE);
	pInterCPU->Run();
	
	while(1);
	return 0;
}

        AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而 Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory 模式通常都是使用 Factory 模式实现。