DEV Community

loading...
Cover image for Factory Design Pattern

Factory Design Pattern

Subhrodip Mohanta
Writing readable and scalable code that unites distributed systems to power your daily apps
Updated on ・3 min read

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;
  }
}
Enter fullscreen mode Exit fullscreen mode

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;
  }
}
Enter fullscreen mode Exit fullscreen mode

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();
  }
}
Enter fullscreen mode Exit fullscreen mode

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());
Enter fullscreen mode Exit fullscreen mode

Program output:

This is Ford.
This is Ferrari.
Enter fullscreen mode Exit fullscreen mode

Class Diagram

alt text

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

Related patterns


Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

Discussion (0)