抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂的模式。这个超级工厂又称为工厂的工厂。
介绍
意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
主要解决:主要解决接口选择的问题。
何时使用:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。
如何解决:在一个产品族里面,定义多个产品。
关键代码:在一个工厂里聚合多个同类产品。
应用实例:工作了,为了参加一些聚会,肯定有两套或多套衣服吧,比如说有商务装(成套,一系列具体产品)、时尚装(成套,一系列具体产品),甚至对于一个家庭来说,可能有商务女装、商务男装、时尚女装、时尚男装,这些也都是成套的,即一系列具体产品。假设一种情况(现实中是不存在的,要不然,没法进入共产主义了,但有利于说明抽象工厂模式),在您的家中,某一个衣柜(具体工厂)只能存放某一种这样的衣服(成套,一系列具体产品),每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解,所有的衣柜(具体工厂)都是衣柜类的(抽象工厂)某一个,而每一件成套的衣服又包括具体的上衣(某一具体产品),裤子(某一具体产品),这些具体的上衣其实也都是上衣(抽象产品),具体的裤子也都是裤子(另一个抽象产品)。
优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。
使用场景: 1、QQ 换皮肤,一整套一起换。 2、生成不同操作系统的程序。
注意事项:产品族难扩展,产品等级易扩展。
代码如下:
shape.h
#pragma once
class Shape
{
public:
Shape();
~Shape();
virtual void draw() = 0;
};
class Circle :public Shape
{
public:
Circle();
~Circle() {};
virtual void draw() override;
};
class Square :public Shape
{
public:
Square();
~Square() {};
virtual void draw() override;
};
class Rectangle :public Shape
{
public:
Rectangle();
~Rectangle() {};
virtual void draw() override;
};
shape.cpp
#include "Shape.h"
#include <iostream>
using namespace std;
Shape::Shape()
{
}
Shape::~Shape()
{
}
Circle::Circle() :Shape()
{
}
void Circle::draw()
{
cout << "Circle::draw()\n";
}
Square::Square() :Shape()
{
}
void Square::draw()
{
cout << "Square::draw()\n";
}
Rectangle::Rectangle() :Shape()
{
}
void Rectangle::draw()
{
cout << "Rectangle::draw()\n";
}
color.h
#pragma once
class Color
{
public:
Color();
~Color();
virtual void fill() = 0;
};
class Red :public Color
{
public:
Red() :Color() {}
~Red() {}
virtual void fill();
};
class Green :public Color
{
public:
Green() :Color() {}
~Green() {}
virtual void fill();
};
class Blue :public Color
{
public:
Blue() :Color() {}
~Blue() {}
virtual void fill();
};
color.cpp
#include "Color.h"
#include <iostream>
using namespace std;
Color::Color()
{
}
Color::~Color()
{
}
void Red::fill()
{
cout << "Red::fill()\n";
}
void Green::fill()
{
cout << "Green::fill()\n";
}
void Blue::fill()
{
cout << "Bule::fill()\n";
}
abstractFactory.h
#pragma once
class Shape;
class Color;
enum ShapeType
{
CIRCLE_TYPE,
SQUARE_TYPE,
RECTANGLE_TYPE
};
enum ColorType
{
RED_TYPE,
GREEN_TYPE,
BLUE_TYPE
};
class AbstractFactory
{
public:
AbstractFactory();
~AbstractFactory();
virtual Shape *getShape(ShapeType shapeType) = 0;
virtual Color *getColor(ColorType colorType) = 0;
};
class ShapeFactory :public AbstractFactory
{
public:
ShapeFactory() :AbstractFactory() {}
~ShapeFactory() {}
Shape *getShape(ShapeType shapeType);
Color *getColor(ColorType colorType) { return nullptr; }
};
class ColorFactory :public AbstractFactory
{
public:
ColorFactory() :AbstractFactory() {}
~ColorFactory() {}
Shape *getShape(ShapeType shapeType) { return nullptr; };
Color *getColor(ColorType colorType);
};
abstractFactory.cpp
#include "AbstractFactory.h"
#include "Shape.h"
#include "Color.h"
AbstractFactory::AbstractFactory()
{
}
AbstractFactory::~AbstractFactory()
{
}
Shape * ShapeFactory::getShape(ShapeType shapeType)
{
if (shapeType == CIRCLE_TYPE)
{
return new Circle();
}
else if (shapeType == SQUARE_TYPE)
{
return new Square();
}
else if (shapeType == RECTANGLE_TYPE)
{
return new Rectangle();
}
else
{
return nullptr;
}
}
Color * ColorFactory::getColor(ColorType colorType)
{
if (colorType == RED_TYPE)
{
return new Red();
}
else if (colorType == GREEN_TYPE)
{
return new Green();
}
else if (colorType == BLUE_TYPE)
{
return new Blue();
}
else
{
return nullptr;
}
}
FactoryProducer.h
#pragma once
class AbstractFactory;
enum FactoryType
{
SHAPE_TYPE,
COLOR_TYPE
};
class FactoryProducer
{
public:
FactoryProducer();
~FactoryProducer();
AbstractFactory * getFactory(FactoryType factoryType);
};
FactoryProducer.cpp
#include "FactoryProducer.h"
#include "AbstractFactory.h"
FactoryProducer::FactoryProducer()
{
}
FactoryProducer::~FactoryProducer()
{
}
AbstractFactory * FactoryProducer::getFactory(FactoryType factoryType)
{
if (factoryType == SHAPE_TYPE)
{
return new ShapeFactory();
}
else if (factoryType == COLOR_TYPE)
{
return new ColorFactory();
}
else
return nullptr;
}
main.cpp
#include "Shape.h"
#include "Color.h"
#include "AbstractFactory.h"
#include "FactoryProducer.h"
#include <iostream>
using namespace std;
int main()
{
FactoryProducer *pFactoryProducer = new FactoryProducer;
AbstractFactory *pAbstractFactory1 = pFactoryProducer->getFactory(SHAPE_TYPE);
Shape *pShape1 = pAbstractFactory1->getShape(CIRCLE_TYPE);
pShape1->draw();
Shape *pShape2 = pAbstractFactory1->getShape(SQUARE_TYPE);
pShape2->draw();
Shape *pShape3 = pAbstractFactory1->getShape(RECTANGLE_TYPE);
pShape3->draw();
AbstractFactory *pAbstractFactory2 = pFactoryProducer->getFactory(COLOR_TYPE);
Color *pColor1 = pAbstractFactory2->getColor(RED_TYPE);
pColor1->fill();
Color *pColor2 = pAbstractFactory2->getColor(GREEN_TYPE);
pColor2->fill();
Color *pColor3 = pAbstractFactory2->getColor(BLUE_TYPE);
pColor3->fill();
delete pColor3;
delete pColor2;
delete pColor1;
delete pAbstractFactory2;
delete pShape3;
delete pShape2;
delete pShape1;
delete pAbstractFactory1;
delete pFactoryProducer;
int d;
cin >> d;
return 0;
}
输出结果:
Circle::draw()
Square::draw()
Rectangle::draw()
Red::fill()
Green::fill()
Bule::fill()