Das abstrakte Fabrikmuster ist ein Softwaredesignmuster, das eine Weise zur Verfügung stellt, eine Gruppe von individuellen Fabriken kurz zusammenzufassen, die ein allgemeines Thema haben. Im normalen Gebrauch schafft die Kundensoftware eine konkrete Durchführung der abstrakten Fabrik und verwendet dann die allgemeinen Schnittstellen, um die konkreten Gegenstände zu schaffen, die ein Teil des Themas sind. Der Kunde weiß nicht (oder Sorge), welcher Beton einwendet, dass es von jeder dieser inneren Fabriken kommt, da es nur die allgemeinen Schnittstellen ihrer Produkte verwendet. Dieses Muster trennt die Details der Durchführung von einer Reihe von Gegenständen von ihrem allgemeinen Gebrauch.

Ein Beispiel davon würde eine abstrakte Fabrikklasse sein, die Schnittstellen zur Verfügung stellt, um mehrere Produkte (z.B und) zu schaffen. Das System würde jede Zahl von abgeleiteten konkreten Versionen der Klasse wie oder, jeder mit einer verschiedenen Durchführung dessen haben, und das würde einen entsprechenden Gegenstand wie schaffen oder. Jedes dieser Produkte wird aus einer einfachen abstrakten Klasse wie abgeleitet, oder deren der Kunde bewusst ist. Der Kundencode würde ein passendes Beispiel bekommen und seine Fabrikmethoden nennen. Jeder der resultierenden Gegenstände würde von derselben Durchführung von DocumentCreator geschaffen und würde ein allgemeines Thema teilen (sie würden alle schmückende oder moderne Gegenstände sein). Der Kunde würde wissen müssen, wie man nur den Auszug oder die Klasse, nicht die spezifische Version behandelt, die es von der konkreten Fabrik bekommen hat.

Eine Fabrik ist die Position oder eine konkrete Klasse im Code, an dem Gegenstände gebaut werden. Die Absicht in der Beschäftigung des Musters soll die Entwicklung von Gegenständen von ihrem Gebrauch isolieren. Das berücksichtigt neue abgeleitete Typen, die ohne Änderung zum Code einzuführen sind, der die Grundklasse verwendet.

Der Gebrauch dieses Musters macht es möglich, konkrete Durchführungen auszuwechseln, ohne den Code zu ändern, der sie sogar an der Durchlaufzeit verwendet. Jedoch kann die Beschäftigung dieses Musters, als mit ähnlichen Designmustern, auf unnötige Kompliziertheit und Extraarbeit im anfänglichen Schreiben des Codes hinauslaufen. Verwendet richtig zahlt die "Extraarbeit" in der zweiten Durchführung der Fabrik aus.

Definition

Die Essenz des Abstrakten Fabrikmethode-Musters soll eine Schnittstelle "zur Verfügung stellen, um Familien von zusammenhängenden oder abhängigen Gegenständen zu schaffen, ohne ihren anzugeben

konkrete Klassen".

Gebrauch

Die Fabrik bestimmt den wirklichen konkreten Typ des Gegenstands, geschaffen zu werden, und es ist hier, dass der Gegenstand wirklich (in C ++, zum Beispiel, vom neuen Maschinenbediener) geschaffen wird. Jedoch gibt die Fabrik nur einen abstrakten Zeigestock zum geschaffenen konkreten Gegenstand zurück.

Das isoliert Kundencode von der Gegenstand-Entwicklung, indem es Kunden gehabt wird, fragt ein Fabrikgegenstand, einen Gegenstand des gewünschten abstrakten Typs zu schaffen und einen abstrakten Zeigestock zum Gegenstand zurückzugeben.

Da die Fabrik nur einen abstrakten Zeigestock, der Kundencode zurückgibt (der um den Gegenstand von der Fabrik gebeten hat), weiß nicht - und wird durch - der wirkliche konkrete Typ des Gegenstands nicht belastet, der gerade geschaffen wurde. Jedoch ist der Typ eines konkreten Gegenstands (und folglich einer konkreten Fabrik) von der abstrakten Fabrik bekannt; zum Beispiel kann die Fabrik es von einer Konfigurationsdatei lesen. Der Kunde hat kein Bedürfnis, den Typ anzugeben, seitdem er bereits in der Konfigurationsdatei angegeben worden ist. Insbesondere das bedeutet:

• Der Kundencode hat keine Kenntnisse überhaupt des konkreten Typs, nicht müssend irgendwelche Kopfball-Dateien oder Klassenbehauptungen in Zusammenhang mit dem konkreten Typ einschließen. Der Kundencode befasst sich nur mit dem abstrakten Typ. Gegenstände eines konkreten Typs werden tatsächlich von der Fabrik geschaffen, aber der Kundencode greift auf solche Gegenstände nur durch ihre abstrakte Schnittstelle zu.
• Das Hinzufügen neuer konkreter Typen wird durch das Ändern des Kundencodes getan, um eine verschiedene Fabrik, eine Modifizierung zu verwenden, die normalerweise eine Linie in einer Datei ist. (Die verschiedene Fabrik schafft dann Gegenstände eines verschiedenen konkreten Typs, aber gibt noch einen Zeigestock desselben abstrakten Typs wie zuvor - so das Isolieren des Kundencodes von der Änderung zurück.) Ist das bedeutsam leichter als das Ändern des Kundencodes, um einen neuen Typ zu realisieren, der das Ändern jeder Position im Code verlangen würde, wo ein neuer Gegenstand geschaffen wird (sowie sicherstellend, dass alle diese Codepositionen auch Kenntnisse des neuen konkreten Typs, durch das Umfassen zum Beispiel einer konkreten Klassenkopfball-Datei haben). Wenn alle Fabrikgegenstände allgemein in einem Singleton-Gegenstand versorgt werden, und der ganze Kundencode den Singleton durchgeht, um auf die richtige Fabrik für die Gegenstand-Entwicklung zuzugreifen, dann ist das Ändern von Fabriken so leicht wie das Ändern des Singleton-Gegenstands.

Struktur

Lepus3 Karte (Legende)

Klassendiagramm

Die Methode "createButton" auf GuiFactory verbindet Rückgegenstände des Typs Button. Welche Durchführung des Knopfs zurückgegeben wird, hängt ab, welche Durchführung von GuiFactory den Methode-Anruf behandelt.

Bemerken Sie, dass, für die Bündigkeit, dieses Klassendiagramm nur die Klassenbeziehungen zeigt, um einen Typ des Gegenstands zu schaffen.

Beispiel

Die Produktion sollte sein entweder "ich bin WinButton" oder "ich bin ein OSXButton", abhängig von dem die Art der Fabrik verwendet wurde. Bemerken Sie, dass die Anwendung keine Idee hat, welcher GUIFactory sie gegeben wird, oder sogar welcher Knopf, den Fabrik schafft.

Java

/* GUIFactory Beispiel - * /

verbinden Sie GUIFactory {\

öffentlicher Knopf createButton ;

}\

Klasse WinFactory führt GUIFactory {\durch

öffentlicher Knopf createButton {\

geben Sie neuen WinButton zurück;

}\

}\

Klasse OSXFactory führt GUIFactory {\durch

öffentlicher Knopf createButton {\

geben Sie neuen OSXButton zurück;

}\}\

verbinden Sie Taste {\

öffentliche leere Farbe ;

}\

Klasse WinButton führt Taste {\durch

öffentliche leere Farbe {\

System.out.println ("bin ich WinButton");

}\}\

Klasse OSXButton führt Taste {\durch

öffentliche leere Farbe {\

System.out.println ("bin ich ein OSXButton");

}\}\

Klassenanwendung {\

öffentliche Anwendung (GUIFactory Fabrik) {\

Taste Button = factory.createButton ;

button.paint ;

}\}\

öffentliche Klasse ApplicationRunner {\

öffentliche statische leere Hauptsache (Schnur [] args) {\

neue Anwendung (createOsSpecificFactory );

}\

öffentlicher statischer GUIFactory createOsSpecificFactory {\

interne Nummer sys = readFromConfigFile ("OS_TYPE");

wenn (sys == 0) {\

geben Sie neuen WinFactory zurück;

} sonst {\

geben Sie neuen OSXFactory zurück;

}\

}\}\

</Quelle>

C#

/* GUIFactory Beispiel - * /

das Verwenden des Systems;

das Verwenden des Systems. Konfiguration;

namespace AbstractFactory

{\

öffentliche Schnittstelle IButton

{\

leere Farbe ;

}\

öffentliche Schnittstelle IGUIFactory

{\

IButton CreateButton ;

}\

öffentliche Klasse OSXButton: IButton

{\

öffentliche leere Farbe

{\

System. Konsole. WriteLine ("bin ich ein OSXButton");

}\ }\

öffentliche Klasse WinButton: IButton

{\ öffentliche leere Farbe {\

System. Konsole. WriteLine ("bin ich WinButton");

}\ }\

öffentliche Klasse OSXFactory: IGUIFactory

{\

IButton IGUIFactory. CreateButton

{\

geben Sie neuen OSXButton zurück;

}\ }\

öffentliche Klasse WinFactory: IGUIFactory

{\ IButton IGUIFactory. CreateButton {\

geben Sie neuen WinButton zurück;

}\ }\

öffentliche Klassenanwendung

{\

öffentliche Anwendung (IGUIFactory Fabrik)

{\

Taste IButton = Fabrik. CreateButton ;

Knopf. Farbe ;

}\ }\

öffentliche Klasse ApplicationRunner

{\

statischer IGUIFactory CreateOsSpecificFactory

{\

//Inhalt von App. Config hat damit C# verkehrt planen

//

//

//

//

// //

//</appSettings>

//</Konfiguration>

spannen Sie sysType = ConfigurationSettings. AppSettings ["OS_TYPE"];

wenn (sysType == "Gewinn")

{\

geben Sie neuen WinFactory zurück;

}

sonst

{\

geben Sie neuen OSXFactory zurück;

}\

}\

statische leere Hauptsache (Schnur [] args)

{\

neue Anwendung (CreateOsSpecificFactory );

Konsole. ReadLine ;

}\ }\}\</Quelle>

C ++

/* GUIFactory Beispiel - * /

1. einschließen

das Verwenden namespace std;

Klassentaste {\

Publikum:

virtuelle leere Farbe = 0;

virtueller ~Button {\

}\

};

Klasse WinButton: öffentliche Taste {\

Publikum:

leere Farbe {\

cout

Knopf-> Farbe ;

löschen Sie Knopf;

löschen Sie Fabrik;

}\

};

GUIFactory * createOsSpecificFactory {\

interne Nummer sys;

cout

wenn (sys == 0) {\

geben Sie neuen WinFactory zurück;

} sonst {\

geben Sie neuen OSXFactory zurück;

}\}\

int Hauptsache (interne Nummer argc, Rotforelle ** argv) {\

Anwendung * newApplication = neue Anwendung (createOsSpecificFactory );

löschen Sie newApplication;

kehren Sie 0 zurück;

}\</Quelle>

Ziel-C

/* GUIFactory Beispiel - * /

1. Import

@protocol-Knopf

- (leere) Farbe;

@end

@interface WinButton: NSObject

@end

@interface OSXButton: NSObject

@end

@protocol GUIFactory

- (id) createButton;

@end

@interface WinFactory: NSObject

@end

@interface OSXFactory: NSObject

@end

@interface-Anwendung: NSObject

- (id) initWithGUIFactory: (id) Fabrik;

+ (id) createOsSpecificFactory: (int) Typ;

@end

@implementation WinButton

- (leere) Farbe {\

NSLog ("Bin ich WinButton.");

}\@end

@implementation OSXButton

- (leere) Farbe {\

NSLog ("Bin ich ein OSXButton.");

}\@end

@implementation WinFactory

- (id) createButton {\

geben Sie [WinButton alloc] init] Autoausgabe] zurück;

}\@end

@implementation OSXFactory

- (id) createButton {\

kehren Sie [OSXButton alloc] init] Autoausgabe] zurück;

}\@end

@implementation-Anwendung

- (id) initWithGUIFactory: (id) Fabrik {\

wenn (selbst = [fantastischer init]) {\

Id-Knopf = [Fabrik createButton];

[Knopf-Farbe];

}\

kehren Sie selbst zurück;

}\

+ (id) createOsSpecificFactory: (int) Typ {\

wenn (Typ == 0) {\

geben Sie [WinFactory alloc] init] Autoausgabe] zurück;

} sonst {\

kehren Sie [OSXFactory alloc] init] Autoausgabe] zurück;

}\}\@end

int Hauptsache (interne Nummer argc, char* argv []) {\

NSAutoreleasePool *pool = NSAutoreleasePool alloc] init];

;//0 ist WinButton

[vereinen Sie Ausgabe];

kehren Sie 0 zurück;

}\</Quelle>

Siehe auch

• Gegenstand-Entwicklung
• Konkrete Klasse
• Fabrikmethode-Muster
• Designmuster

Außenverbindungen

• Abstrakte Fabrik UML Diagramm + formelle Spezifizierung in LePUS3 und Klassen-Z (eine Designbeschreibungssprache)