Factory Design Pattern

This is a Creational Design Pattern under Gang of Four

Also known as

• Simple Factory
• Static Factory Method

Intent

Providing a static method encapsulated in a class called factory, in order to hide the
implementation logic and makes client code focus on usage rather then initialization new objects.

Explanation

Real world example

Lets say we have a web application connected to SQLServer, but now we want to switch to Oracle. To
do so without modifying existing source code, we need to implements Simple Factory pattern, in
which a static method can be invoked to create connection to a given database.

Wikipedia says

Factory is an object for creating other objects – formally a factory is a function or method that
returns objects of a varying prototype or class.

Programmatic Example

We have an interface Car and two implementations Ford and Ferrari.

public interface Car {
  String getDescription();
}

public class Ford implements Car {

  static final String DESCRIPTION = "This is Ford.";

  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

public class Ferrari implements Car {

  static final String DESCRIPTION = "This is Ferrari.";

  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

Enumeration above represents types of cars that we support (Ford and Ferrari).

public enum CarType {

  FORD(Ford::new), 
  FERRARI(Ferrari::new);

  private final Supplier<Car> constructor; 

  CarType(Supplier<Car> constructor) {
    this.constructor = constructor;
  }

  public Supplier<Car> getConstructor() {
    return this.constructor;
  }
}

Then we have the static method getCar to create car objects encapsulated in the factory class
CarsFactory.

public class CarsFactory {

  public static Car getCar(CarType type) {
    return type.getConstructor().get();
  }
}

Now on the client code we can create different types of cars using the factory class.

var car1 = CarsFactory.getCar(CarType.FORD);
var car2 = CarsFactory.getCar(CarType.FERRARI);
LOGGER.info(car1.getDescription());
LOGGER.info(car2.getDescription());

Program output:

This is Ford.
This is Ferrari.

Class Diagram

Applicability

Use the Simple Factory pattern when you only care about the creation of a object, not how to create
and manage it.

Pros

• Allows keeping all objects creation in one place and avoid of spreading 'new' keyword across codebase.
• Allows to write loosely coupled code. Some of its main advantages include better testability, easy-to-understand code, swappable components, scalability and isolated features.

Cons

• The code becomes more complicated than it should be.

Real world examples

• java.util.Calendar#getInstance()
• java.util.ResourceBundle#getBundle()
• java.text.NumberFormat#getInstance()
• java.nio.charset.Charset#forName()
• java.net.URLStreamHandlerFactory#createURLStreamHandler(String) (Returns different singleton objects, depending on a protocol)
• java.util.EnumSet#of()
• javax.xml.bind.JAXBContext#createMarshaller() and other similar methods.

Related patterns

• Factory Method
• Factory Kit
• Abstract Factory

Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

• Samil Ayoub
• Ilkka Seppälä
• Anurag870
• yonghong Xu
• JackieNim
• Girish Kulkarni
• RuchaDalsania