[设计模式] 创建模式之抽象工厂模式

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

介绍

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

 

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。

比如我们同样生产手机外壳，他们所需要的步骤都是相同的，但是不同的手机仍只不同型号的手机的外壳肯定是不太一样的，我们需要多个工厂进行生产，如示例一：

 

示例一：

#pragma once
#include<iostream>
class Product{
public:
	virtual void design() = 0;

};
class oppo :public Product{
public:
	void design()
	{
		std::cout << "oppo:我的手机壳设计是这样的" << std::endl;
	}
};

class vivo :public Product{
public:
	void design()
	{
		std::cout << "vivo:我的手机壳设计是那样的" << std::endl;
	}
};
class abstractFactory{
	virtual void color() = 0;
	virtual void plasticity() = 0;
	virtual  Product* create() = 0;
};


class oppoFactory :public abstractFactory{
public:
	Product* create()
	{
		std::cout << "得到设计要求，可以生产产品" << std::endl;
		return new oppo;
	}
	void color()
	{
		std::cout << "oppo手机壳上这种颜色" << std::endl;
	}
	void plasticity()
	{
		std::cout << "oppo手机壳是这种形状" << std::endl;
	}
};


class vivoFactory :public abstractFactory{
public:
	Product* create()
	{
		std::cout << "得到设计要求，可以生产产品" << std::endl;
		return new vivo;
	}
	void color()
	{
		std::cout << "vivo手机壳上这种颜色" << std::endl;
	}
	void plasticity()
	{
		std::cout << "vivo手机壳是这种形状" << std::endl;
	}
};

如果你看到之前的博客：https://blog.csdn.net/weixin_43519514/article/details/114708857   ，你会感到惊奇，多工厂模式和抽象工厂模式的代码是非常相似的；

其实这没有任何错误，两者都是创造模式，代码看起来相似，其实还是有区别的；

工厂模式强调将一个类的实例化延迟到其子类；而抽象工厂模式强调可以生产一组相关的产品；

看两者定义：

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

在抽象工厂模式中， 接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象

 

为了能够好的理解抽象工厂，我们可以看一下示例二的代码，我们只要创建一个ContrateFactory工厂，就能够的到Shape和Color的相应工厂，按照之前的工厂模式进行生产产品；

 

 

示例二：

class Color{
public:
	virtual void fill() = 0;
};

class Red :public Color{
public:
	void fill()
	{
		std::cout << "red" << std::endl;
	}

};
class Green :public Color{
public:
	void fill()
	{
		std::cout << "green" << std::endl;
	}
};


class Shape {
public:
	virtual	void draw() = 0;
};

class Rectangle :public Shape{
public:
	void draw()
	{
		std::cout << "draw Rectangle" << std::endl;
	}
};

class Square :public Shape{
public:
	void draw()
	{
		std::cout << "draw Square" << std::endl;
	}
};
enum  shape{
	rectangle = 0,
	square
};

enum color{
	red = 0,
	green
};
class Factory{
public:
	virtual Shape* Createshape(shape s) = 0;
	virtual Color* Fillcolor(color c) = 0;
};


class ContrateFactory:public Factory{
public:
	Shape* Createshape(shape s)
	{
		if (s == rectangle)
		{
			return new Rectangle;
		}
		else if (s == square)
		{
			return new Square;
		}

		return nullptr;
	}
	Color* Fillcolor(color c)
	{
		if (c == red)
		{
			return new Red;
		}
		else if (c == green)
		{
			return new Green;
		}
		return nullptr;
	}

};

void Test2()
{
  ContrateFactory cf;
	Shape*  s = cf.Createshape(square);
	Color* c= cf.Fillcolor(red);
	s->draw();
	c->fill();
}

draw Square
red

 

注：如果本篇博客有任何错误和建议，欢迎伙伴们留言，你快说句话啊！