Factory, Abstract Factory and Factory Method

I am really confused about these three terms.

My understanding is that:

• in the Factory pattern, there is no concrete factory. The factory builds the new objects according to the parameters.

• in Abstract Factory pattern, there are multiple concrete factories. The client has to create different concrete factories explicitly.

Is that right?

W开发者_运维知识库hat are the other differences?

Furthermore, what is the Factory Method pattern? Is it same as the Factory pattern?

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 don't know 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.

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

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