Abstract Factory Pattern in Java

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.

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

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.

public interface EraAnimalFactory {

    LandAnimal makeLandAnimal();
    SkyAnimal makeSkyAnimal();
}

public class CenozoicAnimalFactory implements EraAnimalFactory {
    // Implementation for creating Cenozoic animals
}

public class MesozoicAnimalFactory implements EraAnimalFactory {
    // Implementation for creating Mesozoic animals
}

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
    }
}

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.