设计模式之三--抽象工厂模式

1 英文名和别名：

abstract factory，kit

2 意图：

当有多种产品位于不同的产品族，需要创建相互依赖的的对象，无需知道其具体的类。

谈谈我对产品等级和产品族的理解，产品等级指的是具有继承关系的父子或兄弟，而产品等级指的是不同产品等级直接需要相互组合的这样一个关系

3 示例

   考虑这样一个问题，在一个需要考虑跨平台的软件上，需要根据不同的平台创建不同的text和button，在windows下需要创建windows的text和button，在linux下需要创建linux下的text和button，text和windowtext就是产品等级，windowtext和windowsbutton就是产品族

uml类图如下：

      

实现如下：

抽象产品CText

#ifndef __TEXT_H
#define __TEXT_H

class CText
{
public:
	virtual void Show()=0;
	virtual ~CText(){}
protected:
	CText(){}
};

#endif

具体产品CWindowText

#ifndef WINDOWTEXT_H
#define WINDOWTEXT_H

#include "Text.h"

class CWindowText: public	CText
{
public:
	virtual ~CWindowText();
	CWindowText();
	virtual void Show();
};
#endif

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

CWindowText::CWindowText()
{

}

CWindowText::~CWindowText()
{

}

void CWindowText::Show()
{
	 cout<<"CWindowText::Show()\n";
}

具体产品CLiunxText

#ifndef __LINUXTEXT_H
#define __LINUXTEXT_H

#include "Text.h"

class CLinuxText:public CText
{
public:
	CLinuxText();
	virtual ~CLinuxText();
	virtual void Show();
};
#endif

#include "LinuxText.h"

#include <iostream>
using namespace  std;

CLinuxText::CLinuxText()
{

}

CLinuxText::~CLinuxText()
{

}

void CLinuxText::Show()
{
	cout<<"CLinuxText::Show().\n";
}

抽象产品CButton

#ifndef __BUTTON_H
#define __BUTTON_H

class CButton
{
public:
	virtual ~CButton(){}
	virtual void Show()=0;
protected:
	CButton(){}
};
#endif

具体产品CWindowButton

#ifndef __WINDOWBUTTON_H
#define  __WINDOWBUTTON_H

#include "Button.h"

class CWindowButton:public CButton
{
public:
	CWindowButton();
	virtual ~CWindowButton();
	virtual void Show();
};
#endif

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

CWindowButton::CWindowButton()
{

}

CWindowButton::~CWindowButton()
{

}

void CWindowButton::Show()
{
	cout<<"CWindowButton::Show()\n";
}

具体产品CLinuxButton

#ifndef __LINUXBUTTON_H
#define  __LINUXBUTTON_H

#include "Button.h"

class CLinuxButton: public CButton
{

public:
	CLinuxButton();
	virtual ~CLinuxButton();
	virtual void Show();
};

#endif

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


CLinuxButton::CLinuxButton()
{

}

CLinuxButton::~CLinuxButton()
{

}

void CLinuxButton::Show()
{
	cout<<"CLinuxButton::Show().\n";
}

抽象工厂CFacory

#ifndef __FACTORY_H
#define __FACTORY_H

#include "Text.h"
#include "Button.h"

class CFactory
{
public:
	virtual CText* CreateText()=0;
	virtual CButton* CreateButton()=0;
	virtual ~CFactory(){}
protected:
	CFactory(){}
};
#endif

具体工厂CWindowFactory

#ifndef __WINDOWFACTORY_H
#define __WINDOWFACTORY_H

#include "Factory.h"

class CWindowFactroy:public CFactory
{
public:
	virtual CText*  CreateText();
	virtual CButton* CreateButton();
	virtual ~CWindowFactroy();
	CWindowFactroy();
};

#endif 

#include "WindowFactory.h"
#include "WindowButton.h"
#include "WindowText.h"

CText* CWindowFactroy::CreateText()
{
	return ( new CWindowText() );
}

CButton* CWindowFactroy::CreateButton()
{
	return ( new CWindowButton() );
}

CWindowFactroy::CWindowFactroy()
{

}

CWindowFactroy::~CWindowFactroy()
{

}

具体产品CLiunxFactory

#ifndef __LINUXFACTORY_H
#define __LINUXFACTORY_H
#include "Factory.h"

class CLinuxFactory:public CFactory
{
public:
	CLinuxFactory();
	virtual ~CLinuxFactory();
	virtual CText*  CreateText();
	virtual CButton* CreateButton();
};
#endif 

#include "LinuxFactory.h"
#include "LinuxButton.h"
#include "LinuxText.h"

CLinuxFactory::CLinuxFactory()
{

}

CLinuxFactory::~CLinuxFactory()
{

}

CText* CLinuxFactory::CreateText()
{
	return ( new CLinuxText );
}

CButton* CLinuxFactory::CreateButton()
{
	return ( new CLinuxButton );
}

客户端

#include <iostream>
#include "Factory.h"
#include "WindowFactory.h"
#include "Button.h"
#include "Text.h"


void main()
{
	CFactory *pFac=NULL;
	CText* pText=NULL;
	CButton *pButton=NULL;

	pFac=new CWindowFactroy;
	pText=pFac->CreateText();
	pButton=pFac->CreateButton();

	pText->Show();
	pButton->Show();

	delete pFac;
	delete pText;
	delete pButton;
}

今天就到这里，明天总结简单工厂，工厂方法和抽象工厂各自的优点缺点^_^