streamalism.org

1. Oversikt

I denne artikkelen vil vi diskutere designmønsteret for abstrakt fabrikk.

Boken Design Patterns: Elements of Reusable Object-Oriented Software sier at en abstrakt fabrikk “Gir et grensesnitt for å opprette familier med relaterte eller avhengige objekter uten å spesifisere deres konkrete klasser”. Med andre ord lar denne modellen oss lage objekter som følger et generelt mønster.

Et eksempel på abstrakt fabrikk designmønster i JDK er newInstance () av javax.xml.parsers.DocumentBuilderFactory klasse.

2. Abstrakt eksempel på fabrikkdesignmønster

I dette eksemplet lager vi to implementeringer av Factory Method Design-mønsteret: AnimalFactory og FargeFabrikk.

Etter det vil vi administrere tilgangen til dem ved hjelp av en Abstract Factory AbstraktFabrikk:

Først oppretter vi en familie av Dyr klasse og vil senere bruke den i vår abstrakte fabrikk.

Her er Dyr grensesnitt:

offentlig grensesnitt Animal {String getAnimal (); String makeSound (); }

og en konkret implementering And:

offentlig klasse Duck implementerer Animal {@Override public String getAnimal () {return "Duck"; } @ Override public String makeSound () {return "Squeks"; }} 

Videre kan vi lage mer konkrete implementeringer av Dyr grensesnitt (som Hund, bjørn, osv.) nøyaktig på denne måten.

The Abstract Factory håndterer familier av avhengige gjenstander. Med det i tankene skal vi introdusere en familie til Farge som et grensesnitt med noen få implementeringer (Hvit, brun, ...).

Vi hopper over den faktiske koden for nå, men den finner du her.

Nå som vi har flere familier klare, kan vi opprette en AbstraktFabrikk grensesnitt for dem:

offentlig grensesnitt AbstractFactory {T create (String animalType); }

Deretter implementerer vi en AnimalFactory ved hjelp av Design Method-mønsteret som vi diskuterte i forrige avsnitt:

offentlig klasse AnimalFactory implementerer AbstractFactory {@Override public Animal create (String animalType) {if ("Dog" .equalsIgnoreCase (animalType)) {return new Dog (); } annet hvis ("Duck" .equalsIgnoreCase (animalType)) {return new Duck (); } returner null; }} 

På samme måte kan vi implementere en fabrikk for Farge grensesnitt ved hjelp av samme designmønster.

Når alt dette er satt, oppretter vi en Fabrikkleverandør klasse som vil gi oss en implementering av AnimalFactory eller ColorFactory avhengig av argumentet vi leverer til getFactory () metode:

public class FactoryProvider {public static AbstractFactory getFactory (String choice) {if ("Animal" .equalsIgnoreCase (choice)) {return new AnimalFactory (); } annet hvis ("Color" .equalsIgnoreCase (choice)) {returner ny ColorFactory (); } returner null; }}

3. Når skal du bruke abstrakt fabrikkmønster:

• Klienten er uavhengig av hvordan vi lager og komponerer objektene i systemet
• Systemet består av flere familier av objekter, og disse familiene er designet for å brukes sammen
• Vi trenger en kjøretidsverdi for å konstruere en bestemt avhengighet

Mens mønsteret er flott når du lager forhåndsdefinerte objekter, kan det være utfordrende å legge til de nye. For å støtte den nye typen objekter, må du endre AbstraktFabrikk klasse og alle dens underklasser.

4. Oppsummering

I denne artikkelen lærte vi om abstrakt fabrikk design mønster.

Til slutt, som alltid, kan implementeringen av disse eksemplene finnes på GitHub.