Solve design problems using Factory Pattern

Design PatternFactory design pattern is one of the most commonly used patterns in object oriented environment. It is again from the Creational Design pattern category i.e. all about object creation.

There are certain cases where the object creation is complex and might require some level of abstraction so that the client code is unaware of these complexities and internal implementation details. There might be scenarios where object creation is scattered and repetitive in various parts of the code.The Factory pattern resolves these issues by defining an interface which specifically creates the object but gives the flexibility to the implementation classes to decide on which class to instantiate.

The Factory pattern is to define an interface for creating objects but delegates the object creation to the subclasses.

Looking at the problem statement the objective should be:

  • Client should be unaware of the object instantiation
  • Client should access the objects through a common interface.

Which principle of Object Oriented Design is used in Factory pattern?
Encapsulation : because it encapsulates the creation code from the client. And obviously you can then think that the benefits of encapsulation are also applicable for this pattern like loose coupling and cohesion.

Practical Example:
Consider a Garment Factory which produces various types of garments like shirt, trousers. The consumers can request for the required types of garments through the factory. However from consumer’s perspective they are completely unaware of who is creating this object. They just know that the Factory is providing them the required garments.

Problem Statement:
It is a standard practice that objects are created by calling the “new” keyword. Imagine a scenario that there are multiple cases in the client class and we call multiple new keywords for creating new objects.

if (selection.equalsIgnoreCase("Trouser")) {
			return new Trouser();
		} else if (selection.equalsIgnoreCase("Shirt")) {
			return new Shirt();

If we now have to add jacket or sweater we have to keep on modifying the client code and further add the new keyword. This creates a dependency on the client code and in turn makes it difficult to maintain.

Another problem is that the client application has to know how many types of concrete classes are available upfront. Later if we have to add another concrete class e.g. sweater or jacket then client code has to be changed and recompiled.

To resolve above problems factory pattern can be used explicitly.

  • The first problem of accessing too many new keyword can be resolved by using a Factory class.
  • The second problem can be solved by using an interface which the concrete classes will implement and the client will always point to the interface class rather than the concrete classes. So in this way client will be completely unaware of various types of concrete classes which will be required.
What is an interface?
An Interfacein Java is a collection of method definitions without implementation. The class which implements the interface has to provides the implementation and must implement all the methods described in the interface. The interface is a contract which tells the classes what to be done leaves it for the classes to decide on how they can be implemented.

interface Bounceable {
      void setBounce();

The below class diagram will give a complete overview of implementation of Factory Pattern:

Factory Pattern Class Diagram

Factory Pattern Class Diagram

Let’s take a look at the sample code to implement the Factory Pattern:
public interface GarmentType {
	String print();
public class Trouser implements GarmentType {
	public String print() {
		System.out.println("Trouser Created");
		return "Trouser";

public class Shirt implements GarmentType {
	public String print() {
		System.out.println("Shirt Created");
		return "Shirt";
public class GarmentFactory {
	public static GarmentType createGarments(String selection) {
		if (selection.equalsIgnoreCase("Trouser")) {
			return new Trouser();
		} else if (selection.equalsIgnoreCase("Shirt")) {
			return new Shirt();
		throw new IllegalArgumentException("Selection doesnot exist");
public class Client {
	public static void main(String[] args) {
		System.out.println("Enter your selection:");
		BufferedReader br = new BufferedReader(new InputStreamReader(;
		String selection = null;
		try {
			selection = br.readLine();
		} catch (IOException e) {
		GarmentType objGarmentType = GarmentFactory.createGarments(selection);

Advantage of Factory Pattern:
a)This client does not need to know about the subclass of objects which requires to be created. It requires the reference to the interface and the factory object.
b)The object creation processes are taken away from the client to the factory and thereby decoupling the client code with the object creation code. This in turn will help in reusability as this code can be used by other clients.
c)The Factory pattern also helps in the scalability of the application as the client code only refers to the interface and we can add more products implementing the interface without making many changes in the client code.
d)Code maintainability is a beneficial if the application uses Factory pattern as the object creation is centralized.

13 Responses to “Solve design problems using Factory Pattern”

  1. Anonymous

    May 20. 2012

    Excellent article. Good example.

    Reply to this comment
  2. Dan Howard

    May 21. 2012

    You’re better off using an enum rather than Strings so you can avoid the if/else construct and use the faster switch.

    Reply to this comment
  3. free beats

    Oct 29. 2012

    Very nice post. I just stumbled upon your blog and wished to say that I have truly loved browsing your weblog posts. After all I will be subscribing to your rss feed and I am hoping you write once more very soon!

    Reply to this comment
  4. Sriram

    Nov 16. 2012

    Good posting. Just visited your site when I was googling for factory pattern best practices.
    Keep posting…


    Reply to this comment
  5. gokceng

    Mar 31. 2013

    In fact this is not a real GOF design pattern. This is called Simple Factory Pattern. This is more a common idiom than a design pattern.

    Reply to this comment
  6. utkal

    Nov 07. 2013

    Really this website is so fantastik,

    I got so much of thing clearedd from this site.
    I have one request,Could you please explain how hashmap works in JAVA ?

    Ex:- Person object as a key as well as also value.

    what is happening in this synario????

    Reply to this comment
  7. Vaishali

    Feb 24. 2014

    very nice blog. please keep posting.

    Reply to this comment
  8. Radhika

    May 03. 2014

    very nice. Easy way to understand

    Reply to this comment


  1. Gang of Four (GoF) Design Pattern | IdioTechie - October 14, 2012

    [...] Factory Method [...]

  2. Design Best practices using Factory Method Pattern | IdioTechie - October 21, 2012

    [...] repeating the code for Concrete Products like and which can be found in the Factory Pattern [...]

Leave a Reply