This is a Creational Design Pattern under Gang of Four

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

Program output:

This is Ford.
This is 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’ 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.


  • The code becomes more complicated than it should be.

Real world examples

Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

This post is also available on DEV.