Abstract Factory Pattern in Java

Last updated: August 22, 2025

Written by: baeldung

Java

Design Pattern

Learn in

Kotlin

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

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 full code here, but it can be found in the source project.

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.