View Source on Github


Gang of Four Creational

Also known as

  • Simple Factory
  • Static Factory Method


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.


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.";

  public String getDescription() {
    return DESCRIPTION;

public class Ferrari implements Car {
  static final String DESCRIPTION = "This is Ferrari.";

  public String getDescription() {
    return DESCRIPTION;

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

public enum CarType {
  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 CarSimpleFactory.

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);;;;

Program output:

This is Ford.
This Ferrari.

Class Diagram

alt text


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


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


  • The code becomes more complicated than it should be.