Factory, Abstract Factory and Factory Method

Question

I am really confused about these three terms.

My understanding is that:

• in the Factory pattern, there is no concrete factory. The factory builds t

Answer 1

The best way to learn is definately to read. Take a look at this: http://www.dofactory.com/Patterns/Patterns.aspx.

Factory method's defer creation of objects to sub classes. This means that a base class/interface is defined however client code doesn't create an object against this interface. Sub classes which implement the interface are left to initialize an object.

Abstract factories can be found here: http://www.dofactory.com/Patterns/PatternAbstract.aspx#_self2

There is already good information on that site. The next best thing is to check wiki:

http://en.wikipedia.org/wiki/Design_pattern_%28computer_science%29

http://javadesign-patterns.blogspot.com/ is a good place to learn design patterns

Answer 2

FACTORY PATTERN: returns objects of one family
ABSTRACT FACTORY: returns objects of more than one family.

So you may say Abstract factory contains more than one factory

Answer 3

The Gang Of Four "Design Patterns; Elements of Reusable Object-Oriented Software" book contains two entries, "Abstract Factory" (aka 'Virtual Constructor') and "Factory Method"... I dunno about "Concrete Factory." I've heard the term but never given it too much thought.

Factory Method

In "Factory Method" an object has a method which is responsible for the instantiation of another object. A common example would be the JavaScript document object and the creation of HtmlElement objects:

var newDiv = document.createElement('div');

This isn't a great example though, as an important part of the Factory Method is polymorphism. If I could extend document to define another class which defines another createElement this would be prime Factory Method material.

Abstract Factory

An abstract factory is meant to "provide an interface for creating families of related or dependent objects without specifying concrete classes.

The typical straight-out-of-the-book example is a Widget Factory; back in the day when the GoF was published, cross-platform GUI development was a bit of a hassle, so you could define an abstract widget factory class.

That class could have methods createWindow, createButton, createScrollBar etc. In turn, several implementations would be defined to produce Swing widgets or AWT or whatever. Then, depending on configuration, the different class would be instantiated.

Addendum - Concrete Factory

I believe that a Concrete Factory is any non-abstract implementation of Abstract Factory or Factory method.

So, when I write my own generalization of document which overrides createElement, the class I create is a Concrete Factory.

Likewise, while WidgetFactory would be an Abstract Factory, SwingWidgetFactory would be a concrete factory.