Entwurfsmuster (3) Fabrikmethodenmuster

Geben Sie den ursprünglichen Link https://blog.csdn.net/sinat_21107433/article/details/102616501 an

Musterideen für Fabrikmethoden

Die Idee des einfachen Fabrikdesignmusters bestimmt, dass jedes Mal, wenn ein bestimmtes Produkt hinzugefügt wird, die interne Produktzusammensetzung der Fabrik geändert werden muss. Aufgrund des Öffnungs- und Schließprinzips wird die Idee des Öffnens nach außen, des Schließens nach innen und des Konstruktionsmodus für Fabrikmethoden nicht verwendet, um alle spezifischen Produkte auf einheitliche Weise zu erstellen. Verschiedene Fabriken müssen neue Produkte hinzufügen Für verschiedene Produkte. Wenn Sie neue Produkte hinzufügen, müssen Sie entsprechende hinzufügen. Factory.

Factory-Methodenmuster: Definieren Sie eine Schnittstelle zum Erstellen von Objekten, lassen Sie jedoch die Unterklasse entscheiden, welche Klasse instanziiert werden soll. Das Factory-Methodenmuster verzögert die Instanziierung einer Klasse in ihre Unterklassen.

Musterstruktur der Fabrikmethode

Aus der Einführung des oben erwähnten Werksmethodenmusters ist ersichtlich, dass dieses Muster aus den folgenden Hauptelementen besteht:

• Abstract Factory (AbstractFactory): Die Basisklasse aller Factory-Klassen, die bestimmte Produkte herstellen und öffentliche Methoden der Factory-Klasse bereitstellen.
• Betonfabrik (ConcreteFactory): Produzieren Sie bestimmte Produkte
• Abstraktes Produkt (AbstractProduct): Die Basisklasse aller Produkte, die öffentliche Methoden der Produktklasse bereitstellt
• Betonprodukt (ConcreteProduct): spezifische Produktkategorie

Beispiel für ein Factory-Methodenmuster

Das entsprechende UML-Diagramm lautet wie folgt:

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;
}

Zusammenfassung des Factory-Methodenmusters

Zusammenfassend lässt sich sagen, dass Sie, wenn Sie Sport treiben möchten, eine entsprechende Fabrik hinzufügen müssen. Daher entspricht das Fabrikmethodenmodell im Vergleich zum einfachen Fabrikmodell eher dem Prinzip des Öffnens und Schließens.

Vorteil:

1. Die Fabrikmethode wird verwendet, um die vom Kunden benötigten Produkte zu erstellen und gleichzeitig die Details einer bestimmten Produktkategorie zu verbergen, die vor dem Kunden instanziiert werden sollen, und der Benutzer muss sich nur um die Fabrik kümmern, die dem erforderlichen Produkt entspricht.
2. Die Fabrik entscheidet unabhängig, welche Produkte erstellt werden sollen, und der Erstellungsprozess ist in bestimmten Fabrikobjekten gekapselt. Polymorphes Design ist der Schlüssel zum Muster der Fabrikmethode. Wenn
   neue Produkte hinzugefügt werden, muss der ursprüngliche Code nicht geändert werden, wodurch der Code verbessert wird Skalierbarkeit des Systems und entspricht der Entwicklung. Enges Prinzip.

Nachteile:

1. Wenn Sie neue Produkte hinzufügen, müssen Sie gleichzeitig neue Produktfabriken hinzufügen. Die Anzahl der Klassen im System nimmt paarweise zu, was die Komplexität des Systems erhöht. Es müssen mehr Klassen kompiliert und ausgeführt werden, was den zusätzlichen Aufwand erhöht vom System;
2. Sowohl Fabriken als auch Produkte führen Abstraktionsschichten ein. Die im Clientcode verwendeten Abstraktionsschichten (AbstractFactory und AbstractSportProduct) erhöhen die Abstraktionsstufe des Systems und die Schwierigkeit des Verständnisses.

Anwendbare Umgebung:

• Der Client muss die Klasse des zu erstellenden Objekts nicht kennen.
• Die abstrakte Factory-Klasse gibt an, welches Objekt durch ihre Unterklassen erstellt werden soll (unter Verwendung des polymorphen Designs und des Prinzips der Richter-Substitution).