设计模式（4）抽象工厂模式

最新推荐文章于 2024-09-15 16:31:23 发布

碎步の流年

最新推荐文章于 2024-09-15 16:31:23 发布

阅读量113

点赞数 1

分类专栏：设计模式文章标签：设计模式抽象工厂产品族扩展性开闭原则

本文链接：https://blog.csdn.net/qq_24649627/article/details/115069815

版权

设计模式专栏收录该内容

25 篇文章 3 订阅

订阅专栏

抽象工厂模式

之前看到的两个设计模式，都存在各自的缺陷，简单工厂模式中，一个工厂生产多个产品，根据客户提供的产品名称创建对应的产品实例；工厂方法设计模式，则在简单工厂模式的工厂上，创建了许多个工厂类，根据客户提供的产品名称选择可以生产对应产品的工厂进行生产。

然而，很多时候，一个工厂生产的产品并不单一，而是生产一类产品，比如，一个工厂，可以生产足球、篮球、排球等多种产品，把相关的产品归纳为一个“产品族”，由同一个工厂来生产，这就是抽象工厂模式。

抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。其抽象程度更高，每一个具体工厂可以生产一组相关的具体产品对象。

抽象工厂模式结构

抽象工厂模式结构与工厂方法模式结构类似，不同之处在于，一个具体工厂可以生产多种同类相关的产品，由此，抽象工厂模式包含有以下成员：

抽象工厂（AbstractFactory）：所有生产具体产品的工厂类的基类，提供工厂类的公共方法；
具体工厂（ConcreteFactory）：生产具体的产品
抽象产品（AbstractProduct）：所有产品的基类，提供产品类的公共方法
具体产品（ConcreteProduct）：具体的产品类

其UML类图如下：
在这里插入图片描述
可以看出，具体工厂A可以生产两种产品，工厂B也可以生产两种产品。在使用客户端时，只需要声明一个抽象工厂AbstractFactory和两个抽象产品AbstractProduct。
直接上个例子：

abstractfactory.h

#include <iostream>
#include <string.h>

using namespace std;

//抽象产品类AbstractBall
class AbstractBall
{
public:
	AbstractBall(){

	}
	//抽象方法：
	void play(){};
};

//具体产品类Basketball
class Basketball :public AbstractBall
{
public:
	Basketball(){
		play();
	}
	//具体实现方法
	void play(){
		cout << "Play Basketball\n\n";
	}
};

//具体产品类Football
class Football :public AbstractBall
{
public:
	Football(){
		play();
	}
	//具体实现方法
	void play(){
		cout << "Play Football\n\n";
	}
};

//抽象产品类AbstractShirt
class AbstractShirt
{
public:
	AbstractShirt(){}
	//抽象方法：
	void wearShirt(){};
};

//具体产品类BasketballShirt
class BasketballShirt :public AbstractShirt
{
public:
	BasketballShirt(){
		wearShirt();
	}
	//具体实现方法
	void wearShirt(){
		cout << "Wear Basketball Shirt\n\n";
	}
};

//具体产品类FootballShirt
class FootballShirt :public AbstractShirt
{
public:
	FootballShirt(){
		wearShirt();
	}
	//具体实现方法
	void wearShirt(){
		cout << "wear Football Shirt\n\n";
	}
};

//抽象工厂类
class AbstractFactory
{
public:
	virtual AbstractBall *getBall() = 0;
	virtual AbstractShirt *getShirt() = 0;
};

//具体工厂类BasketballFactory
class BasketballFactory :public AbstractFactory
{
public:
	BasketballFactory(){
		cout << "BasketballFactory\n";
	}
	AbstractBall *getBall(){
		cout << "Get basketball\n";
		return new Basketball();
	}
	AbstractShirt *getShirt(){
		cout << "Get basketball shirt\n";
		return new BasketballShirt();
	}
};

//具体工厂类BasketballFactory
class FootballFactory :public AbstractFactory
{
public:
	FootballFactory(){
		cout << "FootballFactory\n";
	}
	AbstractBall *getBall(){
		cout << "Get football\n";
		return new Football();
	}
	AbstractShirt *getShirt(){
		cout << "Get football shirt\n";
		return new FootballShirt();
	}
};

abstractfactory.cpp

#include <iostream>
#include "abstractfactory.h"

int main()
{
	AbstractFactory *fac = NULL;
	AbstractBall *ball = NULL;
	AbstractShirt *shirt = NULL;

	fac = new BasketballFactory();
	ball = fac->getBall();
	shirt = fac->getShirt();
	delete fac;
	delete ball;
	delete shirt;

	fac = new FootballFactory();
	ball = fac->getBall();
	shirt = fac->getShirt();
	delete fac;
	delete ball;
	delete shirt;

	return 0;
}

抽象工厂模式总结

抽象工厂模式中，如果需要新增加一个系列的产品，比如足球系列，只需增加一族新的具体产品类（抽象和具体）并提供一个对应的工厂类即可。但是，如果要在已有的产品族里增加另一个产品，比如除了需要篮球和篮球衣外，还想换双篮球鞋，这时候该怎么办呢？是不是要去修改BasketballFactory呢？由此，Jungle总结了抽象工厂模式的特点：

优点：