Main Page | See live article | Alphabetical index

Abstract factory pattern

A software design pattern, the abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme. In normal usage, the client software would create a concrete implementation of the abstract factory and then use the generic interfaces to create the concrete objects that are part of the theme. The client does not know (nor care) about 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 its general usage.

An example of this would be an abstract factory class documentCreator that provides interfaces to create a number of products (eg. 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 like fancyLetter or modernResume. Each of these products are derived from an simple abstract class like Letter or Resume that the client is aware of. The client code would get an appropriate instantiation of the documentCreator and call its factory functions. 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 only need to know how to handle the abstract Letter or Resume class, not the specific version that it got from the concrete factory.

In software development, a Factory is the location in the code at which objects are constructed. The intent in employing the pattern is to insulate the creation of objects from its usage. This allows for new derived types to be used with no change to the code that uses the base object.

Use of this pattern makes it possible to interchange concrete class without changing the code that use them, even at runtime. However employment of this pattern, as with similar design patterns incurs the risk of unnecessary complexity and extra work in the initial writing of code.

The ClassFactory class is an implementation of the factory in the Java standard library.

Table of contents
1 How to use it
2 Example
3 See also

How to use it

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, via the new operator). However, the factory only returns an abstract pointer (or wrapper class) 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. In particular, this means:


* GUIFactory example in C#

abstract class GUIFactory {

    public static GUIFactory getFactory() {
        int sys = readFromConfigFile("OS_TYPE");
        if (sys==0) {
            return(new WinFactory());
        } else {
            return(new OSXFactory());
   public abstract Button createButton();

class WinFactory:GUIFactory { public override Button createButton() { return(new WinButton()); } }

class OSXFactory:GUIFactory {
    public override Button createButton() {
        return(new OSXButton());

abstract class Button { public string caption; public abstract void paint(); }

class WinButton:Button { public override void paint() { Console.WriteLine("I'm a WinButton: "+caption); } }

class OSXButton:Button { public override void paint() { Console.WriteLine("I'm a OSXButton: "+caption); } }

class Application { static void Main(string[] args) { GUIFactory aFactory = GUIFactory.getFactory(); Button aButton = aFactory.createButton(); aButton.caption = "Play"; aButton.paint(); } //output is //I'm a WinButton: Play //or //I'm a OSXButton: Play }

See also