layout	title	folder	permalink	categories	language	tags
pattern	Factory	factory	/patterns/factory/	Creational	en	Gang of Four

Also known as

• Simple Factory
• Static Factory Method

Intent

Providing a static method encapsulated in a class called the factory, to hide the implementation logic and make client code focus on usage rather than initializing new objects.

Explanation

Real-world example

Imagine an alchemist who is about to manufacture coins. The alchemist must be able to create both gold and copper coins and switching between them must be possible without modifying the existing source code. The factory pattern makes it possible by providing a static construction method which can be called with relevant parameters.

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 Coin and two implementations GoldCoin and CopperCoin.

public interface Coin {
  String getDescription();
}

public class GoldCoin implements Coin {

  static final String DESCRIPTION = "This is a gold coin.";

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

public class CopperCoin implements Coin {
   
  static final String DESCRIPTION = "This is a copper coin.";

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

Enumeration above represents types of coins that we support (GoldCoin and CopperCoin).

@RequiredArgsConstructor
@Getter
public enum CoinType {

  COPPER(CopperCoin::new),
  GOLD(GoldCoin::new);

  private final Supplier<Coin> constructor;
}

Then we have the static method getCoin to create coin objects encapsulated in the factory class CoinFactory.

public class CoinFactory {

  public static Coin getCoin(CoinType type) {
    return type.getConstructor().get();
  }
}

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

LOGGER.info("The alchemist begins his work.");
var coin1 = CoinFactory.getCoin(CoinType.COPPER);
var coin2 = CoinFactory.getCoin(CoinType.GOLD);
LOGGER.info(coin1.getDescription());
LOGGER.info(coin2.getDescription());

Program output:

The alchemist begins his work.
This is a copper coin.
This is a gold coin.

Class Diagram

Applicability

Use the 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.

Known uses

• 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