Patrón de fábrica abstracto
Los dos patrones de diseño vistos anteriormente tienen sus propias deficiencias. En el patrón de fábrica simple, una fábrica produce varios productos y crea las instancias de producto correspondientes según el nombre del producto proporcionado por el cliente; el patrón de diseño del método de fábrica está en el patrón de fábrica simple. En la fábrica, se crean muchas clases de fábrica y la fábrica que puede producir los productos correspondientes se selecciona para la producción de acuerdo con el nombre del producto proporcionado por el cliente.
Sin embargo, muchas veces, una fábrica no produce un solo producto, sino un tipo de producto. Por ejemplo, una fábrica puede producir fútbol, baloncesto, voleibol y otros productos, y los productos relacionados se agrupan en una "familia de productos". Producido por la misma fábrica, este es el modelo de fábrica abstracto.
El patrón de fábrica abstracto proporciona una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases específicas. El grado de abstracción es mayor y cada fábrica de hormigón puede producir un grupo de objetos de productos de hormigón relacionados.
Estructura de patrón de fábrica abstracta
La estructura del patrón de fábrica abstracto es similar a la estructura del patrón del método de fábrica. La diferencia es que una fábrica específica puede producir varios productos del mismo tipo. Por lo tanto, el patrón de fábrica abstracto contiene los siguientes miembros:
- Abstract Factory (AbstractFactory): la clase base de todas las clases de fábrica que producen productos específicos, proporcionando métodos públicos de la clase de fábrica;
- Concrete Factory (ConcreteFactory): producir productos específicos
- Producto abstracto (AbstractProduct): la clase base de todos los productos, que proporciona métodos públicos de la clase de producto
- Producto de hormigón (ConcreteProduct): categoría de producto específica
El diagrama de clases de UML es el siguiente:
se puede ver que la fábrica específica A puede producir dos productos y la fábrica B también puede producir dos productos. Al utilizar el cliente, solo necesita declarar una fábrica abstracta AbstractFactory y dos productos abstractos AbstractProduct.
Directamente en el ejemplo:
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;
}
Resumen del patrón de fábrica abstracto
En el modelo de fábrica abstracta, si necesita agregar una nueva serie de productos, como la serie de fútbol, solo necesita agregar una nueva familia de categorías de productos de concreto (abstracto y concreto) y proporcionar una categoría de fábrica correspondiente. Sin embargo, si desea agregar otro producto a la familia de productos existente, por ejemplo, desea cambiar un par de zapatillas de baloncesto además de la ropa de baloncesto y baloncesto ¿Qué debe hacer en este momento? ¿Vas a modificar BasketballFactory? Así, Jungle resumió las características del patrón de fábrica abstracto:
ventaja:
- El método de fábrica se utiliza para crear los productos requeridos por el cliente y, al mismo tiempo, ocultar los detalles de una categoría de producto específica para ser instanciada del cliente, y el usuario solo necesita preocuparse por la fábrica correspondiente al producto requerido;
- Cuando se agrega una nueva serie de productos, no es necesario modificar el sistema original, lo que mejora la escalabilidad del sistema y se ajusta al principio de apertura y cierre.
Desventajas:
- Al agregar un nuevo producto a una serie de productos existente, el código de la capa de abstracción debe modificarse, lo que cambia en gran medida el sistema original y viola el principio de apertura y cierre.
Entorno aplicable:
- Cuando se necesita utilizar una serie / familia de productos al mismo tiempo, es conveniente utilizar el modelo de fábrica abstracto;
- La estructura del producto es estable y no se agregará ni eliminará un producto del sistema después de que se complete el diseño.