Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Definition
The essence of the Abstract Factory method Pattern is to "Provide an interface for creating families of related or dependent objects without specifying their concrete classes".[1]
Usage
The factory determines the actual concrete type of object to be created, and it is here that the object is actually created (in C++, for instance, by the new operator). However, the factory only returns an abstract pointer to the created concrete object. This insulates client code from object creation by having clients ask a factory object to create an object of the desired abstract type and to return an abstract pointer to the object. As the factory only returns an abstract pointer, the client code (which requested the object from the factory) does not know and is not burdened by the actual concrete type of the object which was just created. However, the type of a concrete object (and hence a concrete factory) is known by the abstract factory; for instance, the factory may read it from a configuration file. The client has no need to specify the type, since it has already been specified in the configuration file. In particular, this means: The client code has no knowledge whatsoever of the concrete type, not needing to include any header files or class declarations relating to the concrete type. The client code deals only with the abstract type. Objects of a concrete type are indeed created by the factory, but the client code accesses such objects only through their
Abstract factory pattern abstract interface. Adding new concrete types is done by modifying the client code to use a different factory, a modification which is typically one line in one file. (The different factory then creates objects of a different concrete type, but still returns a pointer of the same abstract type as before thus insulating the client code from change.) This is significantly easier than modifying the client code to instantiate a new type, which would require changing every location in the code where a new object is created (as well as making sure that all such code locations also have knowledge of the new concrete type, by including for instance a concrete class header file). If all factory objects are stored globally in a singleton object, and all client code goes through the singleton to access the proper factory for object creation, then changing factories is as easy as changing the singleton object.
Structure
Lepus3 chart (legend [2])
Class diagram
The method "createButton" on the GuiFactory interface returns objects of type Button. What implementation of Button is returned depends on which implementation of GuiFactory is handling the method call.
Abstract factory pattern Note that, for conciseness, this class diagram only shows the class relations for creating one type of object.
Example
The output should be either "I'm a WinButton" or "I'm an OSXButton" depending on which kind of factory was used. Note that the Application has no idea what kind of GUIFactory it is given or even what kind of Button that factory creates.
Java
/* GUIFactory example -- */ interface GUIFactory { public Button createButton(); } class WinFactory implements GUIFactory { public Button createButton() { return new WinButton(); } } class OSXFactory implements GUIFactory { public Button createButton() { return new OSXButton(); } }
interface Button { public void paint(); } class WinButton implements Button { public void paint() { System.out.println("I'm a WinButton"); } } class OSXButton implements Button { public void paint() { System.out.println("I'm an OSXButton"); } }
Abstract factory pattern } } public class ApplicationRunner { public static void main(String[] args) { new Application(createOsSpecificFactory()); } public static GUIFactory createOsSpecificFactory() { int sys = readFromConfigFile("OS_TYPE"); if (sys == 0) { return new WinFactory(); } else { return new OSXFactory(); } } }
C#
/* GUIFactory example -- */ using System; using System.Configuration; namespace AbstractFactory { public interface IButton { void Paint(); } public interface IGUIFactory { IButton CreateButton(); } public class OSXButton : IButton { public void Paint() { System.Console.WriteLine("I'm an OSXButton"); } } public class WinButton : IButton { public void Paint()
Abstract factory pattern { System.Console.WriteLine("I'm a WinButton"); } } public class OSXFactory : IGUIFactory { IButton IGUIFactory.CreateButton() { return new OSXButton(); } } public class WinFactory : IGUIFactory { IButton IGUIFactory.CreateButton() { return new WinButton(); } } public class Application { public Application(IGUIFactory factory) { IButton button = factory.CreateButton(); button.Paint(); } } public class ApplicationRunner { static IGUIFactory CreateOsSpecificFactory() { // Contents of App.Config associated with this C# project //<?xml version="1.0" encoding="utf-8" ?> //<configuration> // <appSettings> // <!-- Uncomment either Win or OSX OS_TYPE to test --> // <add key="OS_TYPE" value="Win" /> // <!-- <add key="OS_TYPE" value="OSX" /> --> // </appSettings> //</configuration> string sysType = ConfigurationSettings.AppSettings["OS_TYPE"]; if (sysType == "Win") {
Abstract factory pattern return new WinFactory(); } else { return new OSXFactory(); } } static void Main(string[] args) { new Application(CreateOsSpecificFactory()); Console.ReadLine(); } } }
C++
/* GUIFactory example -- */ #include<iostream> using namespace std; class Button { public: virtual void paint() = 0; virtual ~Button(){ } }; class WinButton: public Button { public: void paint() { cout << "I'm a WinButton"; } }; class OSXButton: public Button { public: void paint() { cout << "I'm an OSXButton"; } }; class GUIFactory { public: virtual Button * createButton() = 0; virtual ~GUIFactory(){
Abstract factory pattern } }; class WinFactory: public GUIFactory { public: Button * createButton() { return new WinButton(); } ~WinFactory(){ } }; class OSXFactory: public GUIFactory { public: Button * createButton() { return new OSXButton(); } ~OSXFactory(){ } }; class Application { public: Application(GUIFactory * factory) { Button * button = factory->createButton(); button->paint(); delete button; delete factory; } }; GUIFactory * createOsSpecificFactory() { int sys; cout << endl << "Enter OS Type(0 - Win, 1 - OSX): "; cin >> sys; if (sys == 0) { return new WinFactory(); } else { return new OSXFactory(); } } int main(int argc, char **argv) { Application * newApplication = new
Objective-C
/* GUIFactory example -- */ #import <Foundation/Foundation.h> @protocol Button - (void)paint; @end @interface WinButton : NSObject <Button> @end @interface OSXButton : NSObject <Button> @end @protocol GUIFactory - (id)createButton; @end @interface WinFactory : NSObject <GUIFactory> @end @interface OSXFactory : NSObject <GUIFactory> @end @interface Application : NSObject - (id)initWithGUIFactory:(id)factory; + (id)createOsSpecificFactory:(int)type; @end @implementation WinButton - (void)paint { NSLog(@"I am a WinButton."); } @end @implementation OSXButton - (void)paint { NSLog(@"I am a OSXButton."); } @end
Abstract factory pattern @implementation WinFactory - (id)createButton { return [[[WinButton alloc] init] autorelease]; } @end @implementation OSXFactory - (id)createButton { return [[[OSXButton alloc] init] autorelease]; } @end @implementation Application - (id)initWithGUIFactory:(id)factory { if (self = [super init]) { id button = [factory createButton]; [button paint]; } return self; } + (id)createOsSpecificFactory:(int)type { if (type == 0) { return [[[WinFactory alloc] init] autorelease]; } else { return [[[OSXFactory alloc] init] autorelease]; } } @end int main(int argc, char* argv[]) { NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; [[Application alloc] initWithGUIFactory:[Application createOsSpecificFactory:0]];// 0 is WinButton [pool release]; return 0; }
References
[1] Gang Of Four [2] http:/ / www. lepus. org. uk/ ref/ legend/ legend. xml
External links
Abstract Factory (http://www.lepus.org.uk/ref/companion/AbstractFactory.xml) UML diagram + formal specification in LePUS3 and Class-Z (a Design Description Language)
10
License
Creative Commons Attribution-Share Alike 3.0 Unported //creativecommons.org/licenses/by-sa/3.0/