The Factory Method pattern

Intent

Define an interface for creating an object, but let

subclasses decide which class to instantiate. Factory Method lets a class defer
instantiation to sub-classes.

In 30 seconds

The catch here is "object creation by subclasses". The

object creation is deferred to subclasses when the knowledge of the kind of
object to be created is not available. For example in high-level framework,

abstract classes application-create specific concrete product classes can't be known.

Frameworks use abstract classes to define and maintain relationship between

objects. When applications create specific subclasses of the framework abstract

classes, they override the factory method and create the specific object

required. Thus Factory Methods eliminates the need to bind application-specific

classes into your framework code.

Motivation

A factory method delegates object creation to a subclass.

Creating objects inside a class with factory method is always more flexible than
creating an object directly. As the Abstract class can provide default object,

and the subclass can provide extended version of an object. It is often used in

Abstract Factory implementation, where there are parallel hierarchies of classes

to be crated. The Abstract Creator knows about the Product interface that is

implemented by the application specific product class and so can use that for

other operations, only the real object creation is delegated to the application

specific subclass.

Structure

Sample Code

Example:

//Abstract Creator



/* It declares the factory method that returns an object of type Product. */


abstract class Creator{


//other operations using product


abstract Product createProduct();


}

 //Concrete Creator



/* Overrides the factory method to return an instance of a ConcreteProduct */


class ConcreteCreator extends Creator{


Product createProduct(){


return new ConcreteProduct();


}


}

//Abstract Product



/* This defines the interface of objects that factory


factory method creates


*/

abstract class Product{



public abstract void execute();


}

/* Implements the Product interface */

class ConcreteProduct extends Product{



public void execute(){


System.out.println("Hello Factory Pattern");


}


}

// Client class

public class Client{



public static void main(String args<>){


//May get it through a Factory maker


ConcreteCreator creator = new ConcreteCreator();


Product p = creator.createProduct();


p.execute();


}


}

In the above example, Client class needn’t know about instance creation. The

creation of Product is deferred to the ConcreteCreator.

Complexities simplified

To have one factory method creating different

products, we can pass a product id to the factory method. To have one
ConcreteCreator for multiple product hierarchies we can use a template (C++

implementation) subclass, which is parameterized by the product class.

Also Known as and Related Patterns

This is also known as Virtual constructor and related to Abstract Factory, Template Methods and Prototypes.

Abstract Factory
The Factory Method pattern is useful for constructing

individual objects for a specific purpose without the construction requester
knowing the specific classes being instantiated. If you need to create a matched

set of such objects, then the Abstract Factory pattern is a more appropriate

pattern.

Template

The Factory Method pattern is often used with the Template

Method pattern.

Prototype

The Prototype pattern provides an alternate way for an

object to work with other objects without knowing the details of their
construction.

(The authors are senior developers at MindTree Consulting. They can be

reached at avijeetd@mindtree.com and href="mailto:satyabrata_dash@mindtree.com">satyabrata_dash@mindtree.com. References:

Design Patterns, elements of reusable object-oriented software by Gamma, Helm, Johnson and Design Patterns in Java by James W. Cooper)