Abstract Factory

Definition

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.

UML Diagram

Picture sourced:[1]

Code Example

JAVA

/*
* GUIFactory example
*/

public 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 extends GUIFactory {
    public Button createButton() {
        return(new WinButton());
    }
}

class OSXFactory extends GUIFactory {
    public Button createButton() {
        return(new OSXButton());
    }
}

public abstract class Button  {
    private String caption;
    public abstract void paint();
    
    public String getCaption(){
        return caption;
    }
    public void setCaption(String caption){
        this.caption = caption;
    }
}

class WinButton extends Button {
    public void paint() {
       System.out.println("I'm a WinButton: " + getCaption());
    }
}

class OSXButton extends Button {
    public void paint() {
       System.out.println("I'm a OSXButton  : " + getCaption());
    }
}

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

C++

#include <memory>
using std::auto_ptr;

class Control { };

class PushControl : public Control { };

class Factory {
 public:
   // Returns Factory subclass based on classKey.  Each
   // subclass has its own getControl() implementation.
   // This will be implemented after the subclasses have
   // been declared.
   static auto_ptr<Factory> getFactory(int classKey);
   virtual auto_ptr<Control> getControl() const = 0;
};

class ControlFactory : public Factory {
public:
   virtual auto_ptr<Control> getControl() const {
      return auto_ptr<Control>(new PushControl());
   }
};

auto_ptr<Factory> Factory::getFactory(int classKey) {
  // Insert conditional logic here.  Sample:
  switch(classKey) {
    default:
      return auto_ptr<Factory>(new ControlFactory());
  }
}

Reference

http://en.wikipedia.org/wiki/Abstract_factory_pattern
http://www.dofactory.com/Patterns/PatternAbstract.aspx