1. Overview
In this article, we’ll discuss the Abstract Factory design pattern.
The book Design Patterns: Elements of Reusable Object-Oriented Software states that an Abstract Factory “provides an interface for creating families of related or dependent objects without specifying their concrete classes”. In other words, this model allows us to create objects that follow a general pattern.
An example of the Abstract Factory design pattern in the JDK is the newInstance() of javax.xml.parsers.DocumentBuilderFactory class.
2. Abstract Factory Design Pattern Example
In this example, we’ll delve into the Abstract Factory pattern using a Java example that involves prehistoric animals.
To illustrate the Abstract Factory pattern, we’ll consider a scenario involving prehistoric animals. These animals can be categorized by their era (Mesozoic or Cenozoic) and their type (land or sky animals). We’ll create a system that allows us to create and manage these animals using the Abstract Factory pattern.
After that, we’ll manage access to them using an abstract factory AnimalAbstractFactory:
Components of the Abstract Factory Pattern
We start by defining two enums, AnimalEra and AnimalType, to represent the eras (Mesozoic and Cenozoic) and animal types (land and sky).
public enum AnimalEra {
MESOZOIC,
CENOZOIC
}
public enum AnimalType {
LAND,
SKY
}
Abstract Product Class: Animal
Next, we create an abstract class Animal to define the common attributes of our animals: their era, type, and name. It also includes an abstract create() method, which will be implemented by concrete subclasses.
public abstract class Animal {
AnimalType type;
AnimalEra era;
String name;
Animal(AnimalType type, AnimalEra era, String name) {
this.type = type;
this.era = era;
this.name = name;
}
abstract void create();
}
Concrete Product Classes: LandAnimal and SkyAnimal
We create two concrete subclasses of Animal: LandAnimal and SkyAnimal. These classes provide specific implementations for creating land and sky animals, respectively.
public class LandAnimal extends Animal {
// Implementation for creating land animals
}
public class SkyAnimal extends Animal {
// Implementation for creating sky animals
}
We’ll skip the actual code for now, but it can be found here.
EraAnimalFactory factory interface
We define an interface, EraAnimalFactory, which declares methods for creating land and sky animals per era. Concrete factory classes will implement this interface to create animals of specific eras.
public interface EraAnimalFactory {
LandAnimal makeLandAnimal();
SkyAnimal makeSkyAnimal();
}
Concrete Factory Classes: CenozoicAnimalFactory and MesozoicAnimalFactory
We create two concrete factory classes, CenozoicAnimalFactory and MesozoicAnimalFactory, which implement the EraAnimalFactory interface. Each factory is responsible for creating animals from a particular era.
public class CenozoicAnimalFactory implements EraAnimalFactory {
// Implementation for creating Cenozoic animals
}
public class MesozoicAnimalFactory implements EraAnimalFactory {
// Implementation for creating Mesozoic animals
}
Abstract factory: AnimalAbstractFactory
AnimalAbstractFactory class is responsible to create animals based on the era and type provided.
public class AnimalAbstractFactory {
Animal animal;
Animal createAnimal(AnimalType type) {
AnimalEra era = getFromConfiguration();
switch (era) {
case MESOZOIC:
animal = new MesozoicAnimalFactory().createAnimal(type);
break;
case CENOZOIC:
animal = new CenozoicAnimalFactory().createAnimal(type);
break;
}
return animal;
}
AnimalEra getFromConfiguration() {
return AnimalEra.MESOZOIC; // Default configuration
}
}
Running the Example
Finally, we have a client class that demonstrates how to use the AnimalAbstractFactory to create prehistoric animals based on their type. The client doesn’t know anything about the inner factories, he just asks for a land animal. This pattern provides an extra level of abstraction.
public class AbstractFactoryRunner {
public static void main(String[] args) {
new AnimalAbstractFactory().createAnimal(AnimalType.LAND);
}
}
3. When to Use Abstract Factory Pattern:
- The client is independent of how we create and compose the objects in the system
- The system consists of multiple families of objects, and these families are designed to be used together
- We need a run-time value to construct a particular dependency
While the pattern is great when creating predefined objects, adding the new ones might be challenging. To support the new type of objects will require changing the AbstractFactory class and all of its subclasses.
4. Summary
In this article, we learned about the Abstract Factory design pattern.
Finally, as always, the implementation of these examples can be found over on GitHub.
