抽象工厂模式

一，简介

抽象工厂模式（Abstract Factory），提供一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

 

二，角色

AbstractFactory

抽象工厂接口，它里面应该包含所有的产品创建的抽象方法

ConcreteFactory 1

具体的工厂，创建具有特定实现的产品对象

AbstractProductA

抽象产品，他们都有可能有两种不同的实现

ProductA 1/ProductA 2

对两个抽象产品的具体分类的实现

三，举例（简单工厂，工厂方法，抽象工厂）

• 简单工厂：简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例

有一家生产处理核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器，一定要显示地告诉生产工厂。

enum CTYPE{ COREA,COREB };

class SingleCore {
public:
	virtual void Show() = 0;
};

class SingleCoreA :public SingleCore {
public:
	void Show() {
		cout << "单核 A" << endl;
	}
};

class SingleCoreB :public SingleCore {
public:
	void Show() {
		cout << "单核 B" << endl;
	}
};

class Factory {
public:
	SingleCore* CreateSingleCore(enum  CTYPE c)
	{
		switch (c)
		{
		case COREA:
			cout << "创建单核 A" << endl;
			return new SingleCoreA;
			break;
		case COREB:
			cout << "创建单核 B" << endl;
			return new SingleCoreB;
			break;
		default:
			break;
		}
	};
};

int main()
{
	Factory fac;
	SingleCore *p = fac.CreateSingleCore(COREA);
	p->Show();

	p = fac.CreateSingleCore(COREB);
	p->Show();

	system("pause");
	return 0;
}

缺点：就是当需要增加新的处理器核类型式，需要修改工厂类，违反了开放封闭原则：可扩展，但不可修改

 

• 工厂方法模式：是指定义一个用于创建对象的接口，让子类决定实例化哪个类。将创建过程延迟到子类进行。

如：生产处理器的厂家，决定再开设一个工厂专门用来生产B型号的单核,一个工厂用来生产A型号的单核。这时客户要A型号的核，就找A工厂要；B型号的，找B工厂要;

class SingleCore {
public:
	virtual void Show() = 0;
};

class SingleCoreA :public SingleCore {
public:
	void Show() {
		cout << "单核 A" << endl;
	}
};

class SingleCoreB :public SingleCore {
public:
	void Show() {
		cout << "单核 B" << endl;
	}
};

class Factory {
public:
	virtual SingleCore* CreateSingleCore() = 0;
};

class FactoryA :public Factory {
public:
	SingleCore* CreateSingleCore() {
		cout << "创建单核 A" << endl;
		return new SingleCoreA();
	}
};

class FactoryB :public Factory {
public:
	SingleCore* CreateSingleCore() {
		cout << "创建单核 B" << endl;
		return new SingleCoreB();
	}
};

int main()
{
	FactoryA m;
	SingleCore *p = m.CreateSingleCore();
	p->Show();

	FactoryB n;
	p = n.CreateSingleCore();
	p->Show();

	system("pause");
	return 0;
}

缺点:每增加一个新产品就需要，增加一个对象的工厂。

 

• 抽象工厂模式：是指定义一个创建一些列相关或相互依赖的对象接口，而无需指定它们具体的类

如：这家公司的技术不断发展，现在可以生产多核的处理器，具体方法：还是开设两个工厂分别用来生产A,B两种型号的处理器

class SingleCore {
public:
	virtual void Show() = 0;
};

class SingleCoreA :public SingleCore {
public:
	void Show() {
		cout << "单核 A" << endl;
	}
};

class SingleCoreB :public SingleCore {
public:
	void Show() {
		cout << "单核 B" << endl;
	}
};

class MultiCore {
public:
	virtual void Show() = 0;
};

class MultiCoreA :public MultiCore {
public:
	void Show() {
		cout << "多核 A" << endl;
	}
};

class MultiCoreB :public MultiCore {
public:
	void Show() {
		cout << "多核 B" << endl;
	}
};


class CoreFactory {
public:
	virtual SingleCore* CreateSingleCore() = 0;
	virtual MultiCore* CreateMultiCore() = 0;
};


class CoreFactoryA :public CoreFactory {
public:
	SingleCore* CreateSingleCore() {
		cout << "创建单核 A" << endl;
		return new SingleCoreA();
	}

	MultiCore* CreateMultiCore() {
		cout << "创建多核 A" << endl;
		return new  MultiCoreA();
	}
};

class CoreFactoryB :public CoreFactory {
public:
	SingleCore* CreateSingleCore() {
		cout << "创建单核 B" << endl;
		return new SingleCoreB();
	}

	MultiCore* CreateMultiCore() {
		cout << "创建多核 B" << endl;
		return new  MultiCoreB();
	}
};

int main()
{
	CoreFactoryB fcb;
	SingleCore* core = fcb.CreateSingleCore();
	MultiCore *mcore = fcb.CreateMultiCore();
	core->Show();
	mcore->Show();

	CoreFactoryA fca;
	core = fca.CreateSingleCore();
	mcore = fca.CreateMultiCore();
	core->Show();
	mcore->Show();


	system("pause");
	return 0;
}

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象里加代码，又要在具体的里面加代码

四，优缺点

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码

五，使用场景

主要解决接口选择的问题，系统的产品有多于一个的产品族，而系统只消费其中某一族的产品

 

简单工厂模式

简单工厂模式不是 23 种里的一种，简而言之，就是有一个专门生产某个产品的类。

比如下图中的鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。

工厂模式

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。

戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。

生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。

后续直接调用鼠标工厂.生产鼠标()即可

抽象工厂模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。

也就是 PC 厂商是个父类，有生产鼠标，生产键盘两个接口。

戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。

创建工厂时，由戴尔工厂创建。

后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

在抽象工厂模式中，假设我们需要增加一个工厂

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。

之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。

之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。 以上。

参考：https://www.cnblogs.com/zhangzeze/p/9392598.html

https://www.runoob.com/design-pattern/abstract-factory-pattern.html