设计模式--抽象工厂模式示例代码

抽象工厂模式：

/*
    抽象工厂模式针对的是产品族，而不是产品等级结构 
    产品族：同一产地或者同一厂商，功能不同
    产品等级：功能相同，产地或者厂商不同
*/

实现要点：

• 在抽象工厂模式中，选用哪种产品族的问题，需要采用工厂方法或简单工厂模式来配合解决。
• 抽象工厂模式和工厂方法模式一样，都把对象的创建延迟到了他的子类中。
• 具体的工厂类可以设计成单例类，他只向外界提供自己唯一的实例。

与其他工厂模式的联系和异同：

• 抽象工厂模式中的具体工厂负责生产一个产品族的产品。而产品族的增加只需要增加与其对应的具体工厂。
• 3种工厂模式都是创建型模式，都是创建对象的，但都把产品具体创建的过程给隐藏了。
• 工厂方法模式是针对一种产品结构，而抽象工厂模式是针对多种产品结构。

 

举例：

有三种水果：苹果，香蕉，鸭梨

有三个国家：中国，美国，日本

三个国家都能生产三种水果，

那么中国生产的三种水果就是一个产品族，三个苹果就是一个产品等级

 

示例：

代码中：抽象的三种水果类，具体国家的水果类（9个类）

抽象工厂类，具体的三个国家类，每个国家类new自己国家的水果对象

当有新的国家加入，如荷兰，只需要创建荷兰的具体水果类与荷兰工厂类，不需要更改已有代码，符合开闭原则

但是如果有新的水果加入时，就要在每个国家类中增加新水果的代码，不符合开闭原则

所以说抽象工厂模式是针对产品族的

#include <iostream>
using namespace std;

//抽象苹果
class AbstrectApple
{
public:
	virtual void ShowName() = 0;
};
//抽象香蕉
class AbstrectBanana
{
public:
	virtual void ShowName() = 0;
};
//抽象鸭梨
class AbstrectPear
{
public:
	virtual void ShowName() = 0;
};


class ChinaApple : public AbstrectApple
{
public:
	virtual void ShowName() {
		cout << "中国苹果" << endl;
	}
};

class ChinaBanana : public AbstrectBanana
{
public:
	virtual void ShowName() {
		cout << "中国香蕉" << endl;
	}
};

class ChinaPear : public AbstrectPear
{
public:
	virtual void ShowName() {
		cout << "中国鸭梨" << endl;
	}
};

class USAApple : public AbstrectApple
{
public:
	virtual void ShowName() {
		cout << "美国苹果" << endl;
	}
};

class USABanana : public AbstrectBanana
{
public:
	virtual void ShowName() {
		cout << "美国香蕉" << endl;
	}
};

class USAPear : public AbstrectPear
{
public:
	virtual void ShowName() {
		cout << "美国鸭梨" << endl;
	}
};

class JapanApple : public AbstrectApple
{
public:
	virtual void ShowName() {
		cout << "日本苹果" << endl;
	}
};

class JapanBanana : public AbstrectBanana
{
public:
	virtual void ShowName() {
		cout << "日本香蕉" << endl;
	}
};

class JapanPear : public AbstrectPear
{
public:
	virtual void ShowName() {
		cout << "日本鸭梨" << endl;
	}
};

//抽象工厂   针对产品族
class AbstractFactory
{
public:
	virtual AbstrectApple* CreateApple() = 0;
	virtual AbstrectBanana* CreateBanana() = 0;
	virtual AbstrectPear* CreatePear() = 0;
};

//中国工厂
class ChinaFactory : public AbstractFactory 
{
public:
	virtual AbstrectApple* CreateApple()
	{
		return new ChinaApple;
	}
	virtual AbstrectBanana* CreateBanana() {
		return new ChinaBanana;
	}
	virtual AbstrectPear* CreatePear() {
		return new ChinaPear;
	}
};

//美国工厂
class USAFactory : public AbstractFactory {
public:
	virtual AbstrectApple* CreateApple()
	{
		return new USAApple;
	}
	virtual AbstrectBanana* CreateBanana() {
		return new USABanana;
	}
	virtual AbstrectPear* CreatePear() {
		return new USAPear;
	}
};

//日本工厂
class JapanFactory : public AbstractFactory {
public:
	virtual AbstrectApple* CreateApple()
	{
		return new JapanApple;
	}
	virtual AbstrectBanana* CreateBanana() {
		return new JapanBanana;
	}
	virtual AbstrectPear* CreatePear() {
		return new JapanPear;
	}
};

void test()
{
	AbstractFactory* Factory = NULL;
	AbstrectApple*  Apple = NULL;
	AbstrectBanana* Banana = NULL;
	AbstrectPear* Pear = NULL;

	Factory = new ChinaFactory;
	Apple = Factory->CreateApple();
	Banana = Factory->CreateBanana();
	Pear = Factory->CreatePear();
	Apple->ShowName();
	Banana->ShowName();
	Pear->ShowName();
	delete Pear;
	delete Banana;
	delete Apple;
	delete Factory;
	
}

int main()
{
	test();
	return 0;
}