Designmønstre - En hurtig guide til Abstract Factory.

Dette er en hurtig guide til at mestre et af de mest almindeligt anvendte designmønstre, den abstrakte fabrik. Selvom kodningseksemplerne er i C ++, som jeg er mere komfortabel med, kan de let justeres til ethvert programmeringssprog som Java, Python, C #, Javascript og mere.

Abstract Factory klassificeres i de kreative designmønstre, som handler om klassificering af objekt / objekt. Mere præcist, hvordan man effektivt bruger arv (klasseskabelsesmønstre) eller delegering (objektoprettelsesmønstre). [af designmønstre forklaret ganske enkelt]

Fabriksdefinition: ”Det er en bygning eller en gruppe af bygninger, hvor produkter fremstilles / oprettes”. Produkter sendes derefter til klienterne til brug på deres eget ansvar. Samtidig er fabriksklienterne mange, det skal være relativt let for kunderne at bestille deres produkt og på samme måde let for fabrikken at tilpasse sig efter kundens behov.

Lad os forbinde prikkerne til at forstå dette designmønster. Vi bruger det, når vi har brug for en grænseflade til oprettelse af afhængige objekter uden nødvendigvis at specificere deres konkrete klasser. Samtidig ønsker vi at indkapsle konstruktionen af ​​"produkter" ved hjælp af arv.

Trin 1 - Nøgleord

Definition af nøgleord er den hemmelige opskrift i denne serie af hurtigguider. Denne metode hjalp mig virkelig med at forstå designmønstre, hardkode dem i mit sind og forstå forskellene mellem andre designmønstre.

  1. Produkt: Det er et objekt, der er bygget af en fabrik, og det er inkluderet i en familie med objekter. Det er meget specifikt, da der ikke er nogen abstraktion af det. Eksempel: BMWdoorHandle, FordDoorHandle.
  2. Abstrakt produkt: Det er et højere niveau af et produkt, der definerer dens familie. Eksempel DoorHandle, DoorWindow
  3. Betonfabrik: Det er en fabrik, der "fysisk" mikrostyrer oprettelsen og færdiggørelsen af ​​et produkt. Eksempel: BMWFactory, FordFactory.
  4. Abstrakt fabrik: Er en grænseflade til at oprette familier af beslægtede eller afhængige objekter uden at specificere deres konkrete klasser. Eksempel: CarFactory

Trin 2 - Diagram

Når vi diskuterer Abstract Factory, skal alt være relevant for nøgleordene ovenfor. Hvis koden begynder at afvige fra disse ord, er noget sandsynligvis ikke helt rigtigt. Lad os lave denne enkle, konkrete fabrik arv fra abstrakt fabrik og produkt fra abstrakt produkt. Diagrammet er så tydeligt som det ser ud; to klasser, der arver fra deres abstrakte klasser. Betonfabrikken er den, der udfører det beskidte arbejde for at skabe specifikke produkter (som identificeres ved den røde linje). Nu med dette diagram er det let at forstå, at dette designmønster let kan opdateres ved at tilføje flere konkrete fabrikker og flere produkter, dvs. ProductC, ProductD osv. Med andre ord kan dette billede kun vokse bredere og bestemt ikke i højden.

Trin 3 - Kode ved eksempel

Jeg vil foreslå at kopiere kodeklassen efter klasse fra mit git-arkiv "Andreas Poyias" og indsætte det i enhver online C ++ editor som c ++ shell, jdoodle eller onlineGDB eller enhver anden og køre det for at se output. Læs derefter kommentarer eller beskrivelse nedenfor. Klassenavnene er skrevet sådan, at jeg efter understregningen giver nøgleordet, der er relateret til det.

AbstractProduct
Det abstrakte produkt er en abstrakt klasse og definerer som forventet en familie af produkter, der arver det. I dette eksempel er det abstrakte produkt aDoorHandle, jeg tilføjede en funktion, der udskriver noget med det formål at fremvise.

# inkluder 
klasse DoorHandle_AbstractProduct
{
offentlig:
 // En dummy-funktion, der udskriver noget
 virtual void printSerialNumber () = 0;
};

Produkt
I dette eksempel er produkterne BMW eller Ford dørhåndtag. De har forskellige serienumre, derfor kan hver klasse udskrive deres eget produktspecifikke serienummer. Vi kunne også have DoorWindoworSteeringWheel. Dørhåndtagsklasserne arver fra den abstrakte klasse ovenfor.

// BMW dørhåndtag [i dørenes familie]
klasse BMWDoorHandle_Product: offentlig DoorHandle_AbstractProduct
{
offentlig:
    // Udskriver produktspecifikt serienummer
    void printSerialNumber () {
        std :: cout << "DoorHandle_Product: BMW123 \ n";
    }
};
// Ford dørhåndtag [i dørenes familie]
klasse FordDoorHandle_Product: offentlig DoorHandle_AbstractProduct
{
offentlig:
    // Udskriver produktspecifikt serienummer
    void printSerialNumber () {
        std :: cout << "DoorHandle_Product: Ford123 \ n";
    }
};

AbstracFactory
 Dette er en meget generisk / abstrakt klasse, som ikke burde have meget mere end createfunktionerne. I sidste ende skaber en fabrik bare produkter.

klasse Car_AbstractFactory
{
offentlig:
 virtuel DoorHandle_AbstractProduct * createDoorHandle () = 0;
 // virtuel DoorWindow_AbstractProduct * createDoorWindow () = 0;
};

ConcreteFactory
Denne fabriksklasse er ganske specifik for produktet. Det er den hårde arbejder, der sætter puslespillet sammen. I dette eksempel er det specifikt for et mærke {BMW, Ford}. Dets job er at returnere en forekomst af et produkt, der er specifikt for dette mærke. Igen, hvis vi ønskede at opretteBMWDoorWindow, kunne vi faktisk oprette en ny funktion, der returnerer et eksempel på den relevante abstrakte klasse. I mit git-arkiv er der også den fulde implementering med theDoorWindow-dele.

klasse BMWCar_ConcreteFactory: offentlig Car_AbstractFactory
{
offentlig:
    DoorHandle_AbstractProduct * createDoorHandle () {
        returnere nye BMWDoorHandle_Product;
    }
};
klasse FordCar_ConcreteFactory: offentlig Car_AbstractFactory
{
offentlig:
    DoorHandle_AbstractProduct * createDoorHandle () {
        returnere nye FordDoorHandle_Product;
    }
};

Hovedfunktion
Endelig er dette det sidste stykke kode. Hovedfunktionen, der fungerer som klient. Klienten kan let “bestille” produkter fra fabrikken og kan bruge dem på enhver måde, han kan lide.

int main ()
{
    // Klient har brug for en doorHandle og en doorWindow
    Car_AbstractFactory * abstractFactory;
    DoorHandle_AbstractProduct * dHandle_AbstractProduct;
 
    // Kunden har brug for produkter fra Ford brand
    abstractFactory = ny FordCar_ConcreteFactory;
    // Ford-betonfabrik skaber dem
    // og returnerer dem til klienten
    dHandle_AbstractProduct = abstractFactory-> createDoorHandle ();
    // Klient bruger produkterne
    dHandle_AbstractProduct -> printSerialNumber ();
    // Nu ønsker kunden produkter, men fra BMW-mærket
    abstractFactory = ny BMWCar_ConcreteFactory;
    // Så BMW betonfabrik skaber dem
    // og returnerer dem til klienten
    dHandle_AbstractProduct = abstractFactory-> createDoorHandle ();
    // Klient bruger produkterne
    dHandle_AbstractProduct -> printSerialNumber ();
retur 0;
}
// Output
// DoorHandle_Product: Ford123
// DoorHandle_Product: BMW123

Fordelene er muligvis ikke umiddelbart indlysende. Men forestil dig et øjeblik, hvor mange produkter en bil har, og hvor mange ting en bilfabrik kan gøre. Forestil dig nu kaoset, der opretholder en dårligt designet kode, hver gang BMW beslutter at ændre et dørhåndtag. Tilføj en ny type førersæde, eller skift endda noget i motoren. Nu tilføje til kompleksiteten, forestil dig at opretholde disse problemer, men for flere mærker. Abstrakt fabrik tilbyder en vedligeholdelig og ren tilgang, der kan bruges i årene fremover. Det ville være vanskeligt for en ny udvikler at rodet sammen og så let at tilføje / fjerne et nyt produkt.

Abstrakt fabrik er lige begyndelsen på denne rejse. Dette er et af de mest anvendte designmønstre, og mange gange bruges det i kombination med andre designmønstre. Den næste blog vil være en hurtig guide til Singleton designmønster. Glem ikke at kunne lide min blog og følge min konto. Dette er for at give mig den tilfredshed, at jeg hjalp nogle medudviklere og presser mig til at fortsætte med at skrive.

Andre hurtigguider om designmønstre:

  1. Designmønstre - En hurtig guide til Abstract Factory.
  2. Designmønstre - En hurtig guide til Bridge Pattern.
  3. Designmønstre - En hurtig guide til Builder Pattern.
  4. Designmønstre - En hurtig guide til Decoratormønster.
  5. Designmønstre - En hurtig guide til Fasademønster.
  6. Designmønstre - En hurtig guide til observatørmønster.
  7. Designmønstre - En hurtig guide til Singleton-mønster.