Factory
Intent
The Factory design pattern is intended to define an interface for creating an object, but allows subclasses to alter the type of objects that will be created. This pattern is particularly useful when the creation process involves complexity.
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 below 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 in Java when the class doesn't know beforehand the exact types and dependencies of the objects it needs to create.
- When a method returns one of several possible classes that share a common super class and wants to encapsulate the logic of which object to create.
- The pattern is commonly used when designing frameworks or libraries to give the best flexibility and isolation from concrete class types.
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.
- JavaFX uses Factory patterns for creating various UI controls tailored to the specifics of the user's environment.
Consequences
Benefits:
- Reduces coupling between the implementation of an application and the classes it uses.
- Supports the Open/Closed Principle, as the system can introduce new types without changing existing code.
Trade-offs:
- The code can become more complicated due to the introduction of multiple additional classes.
- Overuse can make the code less readable if the underlying complexity of the object creation is low or unnecessary.
Related Patterns
- Abstract Factory: Can be considered a kind of Factory that works with groups of products.
- Singleton: Often used in conjunction with Factory to ensure that a class has only one instance.
- Builder: Separates the construction of a complex object from its representation, similar to how factories manage instantiation.
- Factory Kit: Is a factory of immutable content with separated builder and factory interfaces.