Design Patterns - Een korte handleiding voor Abstract Factory.

Dit is een beknopte handleiding voor het beheersen van een van de meest gebruikte ontwerppatronen, de Abstract Factory. Hoewel de codeervoorbeelden in C ++ zijn, omdat ik me er meer op mijn gemak bij voel, kunnen ze eenvoudig worden aangepast aan elke programmeertaal zoals Java, Python, C #, Javascript en meer.

Abstract Factory is ingedeeld in de creatieve ontwerppatronen die allemaal over klasse / object instantiatie gaan. Meer precies, hoe overerving (klassecreatiepatronen) of delegatie (objectcreatiepatronen) effectief te gebruiken. [door Design Patterns eenvoudig uitgelegd]

Fabrieksdefinitie: "Het is een gebouw of een groep gebouwen waar producten worden vervaardigd / gemaakt". Producten worden vervolgens voor eigen verantwoordelijkheid naar de klanten verzonden. Tegelijkertijd zijn er veel klanten in de fabriek, het moet voor de klanten vrij eenvoudig zijn om hun product te bestellen en voor de fabriek even gemakkelijk aan te passen aan de behoeften van de klant.

Laten we de punten verbinden om dit ontwerppatroon te begrijpen. We gebruiken het wanneer we een interface nodig hebben voor het maken van afhankelijke objecten zonder noodzakelijk hun concrete klassen te specificeren. Tegelijkertijd willen we de constructie van 'producten' inkapselen met behulp van overerving.

Stap 1 - Zoekwoorden

Het definiëren van trefwoorden is het geheime recept in deze serie beknopte handleidingen. Deze methode heeft me geholpen de ontwerppatronen echt te begrijpen, ze hard te coderen en de verschillen tussen andere ontwerppatronen te begrijpen.

  1. Product: het is een object gebouwd door een fabriek en het is opgenomen in een familie van objecten. Het is heel specifiek omdat er geen abstractie op is. Voorbeeld: BMWdoorHandle, FordDoorHandle.
  2. Abstract product: het is een weergave op een hoger niveau van een product dat zijn familie definieert. Voorbeeld DoorHandle, DoorWindow
  3. Betonfabriek: het is een fabriek die 'fysiek' micro-beheer maakt van de creatie en voltooiing van een product. Voorbeeld: BMWFactory, FordFactory.
  4. Abstract Factory: is een interface voor het maken van families van gerelateerde of afhankelijke objecten zonder hun concrete klassen op te geven. Voorbeeld: CarFactory

Stap 2 —Diagram

Bij de bespreking van Abstract Factory moet alles relevant zijn voor de bovenstaande zoekwoorden. Als de code van die woorden begint af te wijken, is er waarschijnlijk iets niet helemaal in orde. Laten we het simpel maken, Concrete Factory neemt over van Abstract Factory en Product van Abstract Product. Het diagram is zo duidelijk als het lijkt; twee klassen erven van hun abstracte klassen. De betonfabriek is degene die het vuile werk doet om specifieke producten te maken (te herkennen aan de rode lijn). Met dit diagram is het gemakkelijk te begrijpen dat dit ontwerppatroon gemakkelijk kan worden bijgewerkt door meer concrete fabrieken en meer producten toe te voegen, d.w.z. ProductC, ProductD enz. Met andere woorden, deze afbeelding kan alleen maar breder worden en zeker niet in de hoogte.

Stap 3 - Codeer als voorbeeld

Ik zou willen voorstellen om de code klasse per klasse te kopiëren vanuit mijn git-repository “Andreas Poyias” en deze in elke online C ++ -editor zoals c ++ shell, jdoodle of onlineGDB of een andere te plakken en uit te voeren om de uitvoer te observeren. Lees dan de opmerkingen of beschrijving hieronder. De klassennamen zijn zo geschreven dat ik na het onderstrepingsteken het bijbehorende trefwoord geef.

AbstractProduct
Het abstracte product is een abstracte klasse en definieert zoals verwacht een familie van producten die ervan erven. In dit voorbeeld is het abstracte product aDoorHandle. Ik heb een functie toegevoegd die iets afdrukt om het te presenteren.

# include 
class DoorHandle_AbstractProduct
{
openbaar:
 // Een dummy-functie die iets afdrukt
 virtuele ongeldige printSerialNumber () = 0;
};

Artikel
In dit voorbeeld zijn de producten BMW of Ford deurklink. Ze hebben verschillende serienummers, daarom kan elke klasse zijn eigen productspecifieke serienummer afdrukken. We kunnen ook DoorWindoworSteeringWheel hebben. De klassen van de portiergrepen erven van de abstracte klasse hierboven.

// BMW deurklink [in de familie van doorHandles]
klasse BMWDoorHandle_Product: public DoorHandle_AbstractProduct
{
openbaar:
    // Drukt productspecifiek serienummer af
    void printSerialNumber () {
        std :: cout << "DoorHandle_Product: BMW123 \ n";
    }
};
// Ford deurklink [in de familie van doorHandles]
klasse FordDoorHandle_Product: public DoorHandle_AbstractProduct
{
openbaar:
    // Drukt productspecifiek serienummer af
    void printSerialNumber () {
        std :: cout << "DoorHandle_Product: Ford123 \ n";
    }
};

AbstracFactory
 Dit is een zeer generieke / abstracte klasse die niet veel meer mag hebben dan de createfuncties. Uiteindelijk maakt een fabriek alleen maar producten.

class Car_AbstractFactory
{
openbaar:
 virtual DoorHandle_AbstractProduct * createDoorHandle () = 0;
 // virtual DoorWindow_AbstractProduct * createDoorWindow () = 0;
};

ConcreteFactory
Deze fabrieksklasse is vrij specifiek voor het product. Het is de harde werker die de puzzel samenstelt. In dit voorbeeld is het specifiek voor een merk {BMW, Ford}. Het is zijn taak om een ​​exemplaar van een product te retourneren dat specifiek is voor dat merk. Nogmaals, als we BMWDoorWindow wilden maken, zouden we eigenlijk een nieuwe functie kunnen maken die een instantie van de relevante abstracte klasse retourneert. In mijn git repository is er ook de volledige implementatie met deDoorWindow-onderdelen.

klasse BMWCar_ConcreteFactory: public Car_AbstractFactory
{
openbaar:
    DoorHandle_AbstractProduct * createDoorHandle () {
        retourneer nieuwe BMWDoorHandle_Product;
    }
};
klasse FordCar_ConcreteFactory: public Car_AbstractFactory
{
openbaar:
    DoorHandle_AbstractProduct * createDoorHandle () {
        retourneer nieuwe FordDoorHandle_Product;
    }
};

Hoofdfunctie
Ten slotte is dit het laatste stukje code. De hoofdfunctie die als client werkt. De klant kan producten in de fabriek gemakkelijk 'bestellen' en deze op elke gewenste manier gebruiken.

int main ()
{
    // Klant heeft een doorHandle en een doorWindow nodig
    Car_AbstractFactory * abstractFactory;
    DoorHandle_AbstractProduct * dHandle_AbstractProduct;
 
    // De klant heeft producten van het merk Ford nodig
    abstractFactory = new FordCar_ConcreteFactory;
    // Ford betonfabriek maakt ze
    // en stuurt ze terug naar de client
    dHandle_AbstractProduct = abstractFactory-> createDoorHandle ();
    // Klant gebruikt de producten
    dHandle_AbstractProduct -> printSerialNumber ();
    // Nu wil de klant producten maar van het merk BMW
    abstractFactory = new BMWCar_ConcreteFactory;
    // Dus de BMW betonfabriek maakt ze
    // en stuurt ze terug naar de client
    dHandle_AbstractProduct = abstractFactory-> createDoorHandle ();
    // Klant gebruikt de producten
    dHandle_AbstractProduct -> printSerialNumber ();
terugkeer 0;
}
// Uitgang
// DoorHandle_Product: Ford123
// DoorHandle_Product: BMW123

Voordelen zijn misschien niet meteen duidelijk. Maar stel je eens voor hoeveel producten een auto heeft en hoeveel dingen een autofabriek kan doen. Stel je nu de chaos voor die een slecht ontworpen code handhaaft telkens wanneer BMW besluit een deurklink te wijzigen. Voeg een nieuw type bestuurdersstoel toe of verander zelfs iets in de motor. Stelt u nu voor aan de complexiteit, stel u voor dat u deze problemen handhaaft, maar voor meerdere merken. Abstracte fabriek biedt een onderhoudbare en schone aanpak, die jarenlang kan worden gebruikt. Het zou moeilijk zijn voor een nieuwe ontwikkelaar om een ​​fout te maken en zo eenvoudig om een ​​nieuw product toe te voegen / te verwijderen.

Abstracte fabriek is slechts het begin van deze reis. Dit is een van de meest gebruikte ontwerppatronen en wordt vaak gebruikt in combinatie met andere ontwerppatronen. De volgende blog is een beknopte handleiding voor het ontwerppatroon van Singleton. Vergeet niet mijn blog leuk te vinden en mijn account te volgen. Dit is om mij de voldoening te geven dat ik sommige mede-ontwikkelaars heb geholpen en me aanspoort om te blijven schrijven.

Andere snelgidsen over ontwerppatronen:

  1. Design Patterns - Een korte handleiding voor Abstract Factory.
  2. Design Patterns - Een korte handleiding voor Bridge Pattern.
  3. Design Patterns - Een korte handleiding voor Builder Pattern.
  4. Design Patterns - Een korte handleiding voor Decorator Pattern.
  5. Ontwerppatronen - Een korte handleiding voor gevelpatroon.
  6. Ontwerppatronen - Een korte handleiding voor het waarnemerspatroon.
  7. Design Patterns - Een korte handleiding voor Singleton Pattern.