Patrón de diseño (3) Patrón de método de fábrica

Proporcione el enlace original https://blog.csdn.net/sinat_21107433/article/details/102616501

Ideas de patrones de métodos de fábrica

La idea del patrón de diseño de fábrica simple determina que cada vez que se agrega un producto específico, se debe cambiar la composición interna del producto de la fábrica. Debido al principio de apertura y cierre, la idea de abrir al mundo exterior, cerrar al interior y el modo de diseño del método de fábrica no se utiliza para crear todos los productos específicos de manera unificada. Las diferentes fábricas necesitan agregar nuevos productos para diferentes productos Al agregar nuevos productos, es necesario agregar los correspondientes Fábrica.

Patrón de método de fábrica: defina una interfaz para crear objetos, pero deje que la subclase decida qué clase instanciar. El patrón del método de fábrica retrasa la instanciación de una clase a sus subclases.

Estructura del patrón del método de fábrica

A partir de la introducción del patrón del método de fábrica mencionado anteriormente, se puede ver que este patrón se compone de los siguientes miembros principales:

• 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

Ejemplo de patrón de método de fábrica

El diagrama UML correspondiente es el siguiente:

factorymethod.h

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

using namespace std;

//抽象产品类AbstractProduct
class AbstractSportProduct
{
    
    
public:
  AbstractSportProduct() {
    
    }
  //抽象方法：
  void printName(){
    
    };
  void play(){
    
    };
};

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

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

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

//抽象工厂类
class AbstractFactory
{
    
    
public:
  virtual AbstractSportProduct *getSportProduct() = 0;
};

//具体工厂类BasketballFactory
class BasketballFactory : public AbstractFactory
{
    
    
public:
  BasketballFactory()
  {
    
    
    cout << "BasketballFactory\n";
  }
  AbstractSportProduct *getSportProduct()
  {
    
    
    cout << "Basketball";
    return new Basketball();
  }
};

//具体工厂类FootballFactory
class FootballFactory : public AbstractFactory
{
    
    
public:
  FootballFactory()
  {
    
    
    cout << "FootballFactory\n";
  }
  AbstractSportProduct *getSportProduct()
  {
    
    
    cout << "Football";
    return new Football();
  }
};

//具体工厂类VolleyballFactory
class VolleyballFactory : public AbstractFactory
{
    
    
public:
  VolleyballFactory()
  {
    
    
    cout <<  "VolleyballFactory\n";
  }
  AbstractSportProduct *getSportProduct()
  {
    
    
    cout << "Valleyball";
    return new Volleyball();
  }
};

factorymethod.cpp

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

using namespace std;

int main()
{
    
    
	cout << "工厂方法模式\n\n";
	
	//定义工厂类对象和产品类对象
	AbstractFactory *fac = NULL;
	AbstractSportProduct *product = NULL;

	fac = new BasketballFactory();
	product = fac->getSportProduct();
	if (fac)
	{
    
    
		delete fac;
	}
	if (product) {
    
    
		delete product;
	}

	fac = new FootballFactory();
	product = fac->getSportProduct();
	if (fac)
	{
    
    
		delete fac;
	}
	if (product) {
    
    
		delete product;
	}

	fac = new VolleyballFactory();
	product = fac->getSportProduct();	
	if (fac)
	{
    
    
		delete fac;
	}
	if (product) {
    
    
		delete product;
	}

	return 0;
}

Resumen del patrón del método de fábrica

En resumen, se puede ver que si desea practicar un deporte, debe agregar una fábrica en consecuencia. Por lo tanto, en comparación con el modelo de fábrica simple, el modelo de método de fábrica está más en línea con el principio de apertura y cierre.

ventaja:

1. 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;
2. La fábrica decide de forma independiente qué productos crear, y el proceso de creación se encapsula en objetos específicos de la fábrica. El diseño polimórfico es la clave del patrón del método de fábrica; cuando
   se agregan nuevos productos, no hay necesidad de modificar el código original, lo que mejora la escalabilidad del sistema y se ajusta al desarrollo Principio de cierre.

Desventajas:

1. Al agregar nuevos productos, debe agregar nuevas fábricas de productos al mismo tiempo. El número de clases en el sistema aumenta en pares, lo que aumenta la complejidad del sistema. Se deben compilar y ejecutar más clases, lo que aumenta la sobrecarga adicional del sistema;
2. Tanto las fábricas como los productos introducen capas de abstracción Las capas de abstracción (AbstractFactory y AbstractSportProduct) utilizadas en el código del cliente aumentan el nivel de abstracción del sistema y la dificultad de comprensión.

Entorno aplicable:

• El cliente no necesita saber la clase del objeto que necesita crear;
• La clase de fábrica abstracta especifica qué objeto crear a través de sus subclases (utilizando el diseño polimórfico y el principio de sustitución de Richter)