Jump to content

Abstract factory pattern

From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by 159.50.101.8 (talk) at 08:22, 10 March 2009 (Not sure why the last editor chamnged the structs to classes. But if 'class' is to be used must have public). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

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 (or 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 is derived from a simple abstract class like Letter or Resume of which the client is aware. The client code would get an appropriate instantiation 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, 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 their usage. This allows for new derived types to be introduced with no change to the code that uses the base class.

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

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, 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 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

The class diagram of this design pattern is as shown here:

The Lepus3 chart (legend) of this design pattern is as shown here:

This class diagram does not emphasize the usage of abstract factory pattern in creating families of related or non related objects.

Example

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();
        }
    }
}

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.

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace Abstract_factory
{
    public interface IButton
    {
        void Paint();
    }
    public class WinButton : IButton
    {
        #region IButton Members

        public void Paint()
        {
            Console.Out.WriteLine("This is a WinButton");
        }

        #endregion
    }
    public class OSXButton : IButton
    {
        #region IButton Members

        public void Paint()
        {
            Console.Out.WriteLine("This is a OSXButton");
        }

        #endregion
    }
    public interface IGUIFactory
    {
        IButton CreateButton();
    }
    public class WinFactory : IGUIFactory
    {
        #region IGUIFactory Members

        public IButton CreateButton()
        {
            return new WinButton();
        }

        #endregion
    }
    public class OSXFactory : IGUIFactory
    {
        #region IGUIFactory Members

        public IButton CreateButton()
        {
            return new OSXButton();
        }

        #endregion
    }
    public class Application
    {
        public Application(IGUIFactory factory)
        {
            IButton button = factory.CreateButton();
            button.Paint();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            IGUIFactory factory1 = new WinFactory();
            IGUIFactory factory2 = new OSXFactory();
            Application app1 = new Application(factory1);
            Application app2 = new Application(factory2);
            Console.ReadLine();
        }
    }
}

C++

#include <iostream>
#include <memory>
using namespace std;

/* Abstract base types */

//Abstract Class Button
class Button
{
    public:
	virtual void paint() const = 0; // pure virtual
};

//Abstract Class Factory
class GUIFactory
{
    public:
	virtual auto_ptr<Button> createButton() const = 0; // pure virtual
};

/* Button Types */
//instantiated button class derived from Abstract class
class WinButton : public Button
{
    public:
	void paint() const
	{
		cout << "I'm a WinButton" << endl;
	}
};


//instantiated button class derived from Abstract class
class OSXButton : public Button
{
    public:
	void paint() const
	{
		cout << "I'm an OSXButton" << endl;
	}
};

/* Factory Types */
//instantiated factory class derived from Abstract class
class WinFactory : public GUIFactory
{
    public:
	auto_ptr<Button> createButton() const
	{
		return auto_ptr<Button>( new WinButton() );
	}
};

//instantiated factory class derived from Abstract class
class OSXFactory : public GUIFactory
{
    public:
	auto_ptr<Button> createButton() const
	{
		return auto_ptr<Button>( new OSXButton() );
	}
};

/* Application: helper class for this example */
class Application 
{
    public:
	Application( const GUIFactory & factory )
	{
		factory.createButton()->paint();
	}
};

int main(int argc, char* argv[])
{
	/* Create two different types of factories... */
	WinFactory factory1;
	OSXFactory factory2;

	/* ... and create an application using either factory, using a single application interface */
	Application app1(factory1);
	Application app2(factory2);

	return 0;
}

See also

Retrieved from "https://en.wikipedia.org/enwiki/w/index.php?title=Abstract_factory_pattern&oldid=276224265"