The abstract factory pattern is a software design pattern

Design pattern (computer science)

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that...

 that provides a way to encapsulate a group of individual factories

Factory object

In object-oriented computer programming, a factory is an object for creating other objects. It is an abstraction of a constructor, and can be used to implement various allocation schemes. For example, using this definition, singletons implemented by the singleton pattern are formal factories.A...

 that have a common theme. In normal usage, the client software creates a concrete implementation of the abstract factory and then uses the generic interface

Interface (computer science)

In the field of computer science, an interface is a tool and concept that refers to a point of interaction between components, and is applicable at the level of both hardware and software...

s to create the concrete object

Object (computer science)

In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure...

s that are part of the theme. The client

Client (computing)

A client is an application or system that accesses a service made available by a server. The server is often on another computer system, in which case the client accesses the service by way of a network....

 does not know (or care) which concrete objects it gets from each of these internal factories since it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from their general usage.

An example of this would be an abstract factory class DocumentCreator that provides interfaces to create a number of products (e.g. createLetter and createResume). The system would have any number of derived concrete versions of the DocumentCreator class like FancyDocumentCreator or ModernDocumentCreator, each with a different implementation of createLetter and createResume that would create a corresponding object

Object (computer science)

In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure...

 like FancyLetter or ModernResume. Each of these products is derived from a simple abstract class like Letter or Resume of which the client

Client (computing)

A client is an application or system that accesses a service made available by a server. The server is often on another computer system, in which case the client accesses the service by way of a network....

 is aware. The client code would get an appropriate instance

Instance (computer science)

In object-oriented programming an instance is an occurrence or a copy of an object, whether currently executing or not. Instances of a class share the same set of attributes, yet will typically differ in what those attributes contain....

 of the DocumentCreator and call its factory methods. Each of the resulting objects would be created from the same DocumentCreator implementation and would share a common theme (they would all be fancy or modern objects). The client would need to know how to handle only the abstract Letter or Resume class, not the specific version that it got from the concrete factory.

In software development

Software development

Software development is the development of a software product...

, a factory is the location or a Concrete Class in the code at which objects are constructed. The intent in employing the pattern is to insulate the creation of objects from their usage. This allows for new derived types

Subtype

In programming language theory, subtyping or subtype polymorphism is a form of type polymorphism in which a subtype is a datatype that is related to another datatype by some notion of substitutability, meaning that program constructs, typically subroutines or functions, written to operate on...

 to be introduced with no change to the code that uses the base class.

Use of this pattern makes it possible to interchange concrete implementations without changing the code that uses them, even at runtime. However, employment of this pattern, as with similar design pattern

Design pattern (computer science)

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that...

s, may result in unnecessary complexity and extra work in the initial writing of code. Used correctly the "extra work" pays off in the second implementation of the factory.

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".

Usage

The factory determines the actual concrete type of object

Object (computer science)

In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure...

 to be created, and it is here that the object is actually created (in C++, for instance, by the new operator

Operator (programming)

Programming languages typically support a set of operators: operations which differ from the language's functions in calling syntax and/or argument passing mode. Common examples that differ by syntax are mathematical arithmetic operations, e.g...

). However, the factory only returns an abstract pointer to the created concrete object

Object (computer science)

In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure...

.

This insulates client code from object creation by having clients ask a factory object

Factory object

In object-oriented computer programming, a factory is an object for creating other objects. It is an abstraction of a constructor, and can be used to implement various allocation schemes. For example, using this definition, singletons implemented by the singleton pattern are formal factories.A...

 to create an object of the desired abstract type

Abstract type

In programming languages, an abstract type is a type in a nominative type system which cannot be instantiated. An abstract type may have no implementation, or an incomplete implementation...

 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
  Concrete
  Concrete is a composite construction material, composed of cement and other cementitious materials such as fly ash and slag cement, aggregate , water and chemical admixtures.The word concrete comes from the Latin word...
  
   type
  Data type
  In computer programming, a data type is a classification identifying one of various types of data, such as floating-point, integer, or Boolean, that determines the possible values for that type; the operations that can be done on values of that type; the meaning of the data; and the way values of...
  
  , not needing to include any header file
  Header file
  Some programming languages use header files. These files allow programmers to separate certain elements of a program's source code into reusable files. Header files commonly contain forward declarations of classes, subroutines, variables, and other identifiers...
  
  s or class
  Class (computer science)
  In object-oriented programming, a class is a construct that is used as a blueprint to create instances of itself – referred to as class instances, class objects, instance objects or simply objects. A class defines constituent members which enable these class instances to have state and behavior...
  
   declaration
  Declaration (computer science)
  In programming languages, a declaration specifies the identifier, type, and other aspects of language elements such as variables and functions. It is used to announce the existence of the element to the compiler; this is important in many strongly-typed languages that require variables and their...
  
  s 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 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
  Singleton pattern
  In software engineering, the singleton pattern is a design pattern used to implement the mathematical concept of a singleton, by restricting the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system...
  
   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.

Lepus3

Lepus3

LePUS3 is a language for modelling and visualizing object-oriented programs and design patterns. It is defined as a formal specification language, formulated as an axiomatized subset of First-order predicate logic. A diagram in LePUS3 is also called a Codechart...

 chart (legend)

Class diagram

Class diagram

In software engineering, a class diagram in the Unified Modeling Language is a type of static structure diagram that describes the structure of a system by showing the system's classes, their attributes, operations , and the relationships among the classes.- Overview :The class diagram is the main...

 

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.

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");
}
}
class Application {
public Application(GUIFactory factory) {
Button button = factory.createButton;
button.paint;
}
}

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
{
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
//
//
//
//
//
//
//
//
string sysType = ConfigurationSettings.AppSettings["OS_TYPE"];
if (sysType "Win")
{
return new WinFactory;
}
else
{
return new OSXFactory;
}
}

static void Main(string[] args)
{
new Application(CreateOsSpecificFactory);
Console.ReadLine;
}
}
}

C++

/* GUIFactory example -- */

1. include

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{
}
};

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 Application(createOsSpecificFactory);
return 0;
}

See also

• Object creation
• Concrete class
• Factory method pattern
  Factory method pattern
  The factory method pattern is an object-oriented design pattern to implement the concept of factories. Like other creational patterns, it deals with the problem of creating objects without specifying the exact class of object that will be created.The creation of an object often requires complex...
  
  
• Design Pattern
  Design pattern (computer science)
  In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that...
  
  

External links

• Abstract Factory UML diagram + formal specification in LePUS3 and Class-Z (a Design Description Language)