📚 Table of Contents

1. Introduction
2. What is the Abstract Factory Pattern?
3. Key Concepts
4. Real-World Analogy
5. Java Example: GUI Toolkit 5.1. Abstract Product Interfaces 5.2. Concrete Products 5.3. Abstract Factory 5.4. Concrete Factories 5.5. Client Code 5.6. Application Runner
6. When to Use Abstract Factory
7. Advantages
8. Disadvantages
9. Why Use Abstract Factory
10. Why Not Use It?
11. Alternative Patterns
12. Conclusion
13. Factory Method vs Abstract Factory Detailed Comparison

Abstract Factory Design Pattern in Java: Complete Guide with Examples

“Design patterns are the blueprints for building scalable and maintainable software. Among them, the Abstract Factory pattern stands out when you need to build families of related objects.”

Introduction

Software systems often need to create families of related objects. For instance, a GUI toolkit might support different themes (dark, light) or platforms (Windows, macOS). In such cases, how can you ensure that components like buttons and checkboxes match the selected theme or platform?

That’s where the Abstract Factory pattern shines.

What is the Abstract Factory Pattern?

The Abstract Factory Pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Think of it as:

“A factory of factories.”

Instead of creating objects directly, the client uses a factory that produces other factories, each responsible for creating a set of related objects.

Key Concepts

Real-World Analogy

Imagine you're designing furniture for two types of houses: Victorian and Modern. You need a Chair and a Table for both styles.

You don’t want to accidentally place a Modern Chair in a Victorian room. So you create a factory for each style:

• VictorianFurnitureFactory: creates VictorianChair and VictorianTable
• ModernFurnitureFactory: creates ModernChair and ModernTable

Your client just selects the style and gets the matching furniture without worrying about the internal details.

Java Example: GUI Toolkit

Let’s design a GUI framework that supports Windows and macOS platforms. Each platform has its own version of Button and Checkbox.

Abstract Product Interfaces

public interface Button {
    void paint();
}

public interface Checkbox {
    void paint();
}

Concrete Products

public class WindowsButton implements Button {
    public void paint() {
        System.out.println("Rendered Windows Button");
    }
}

public class MacButton implements Button {
    public void paint() {
        System.out.println("Rendered Mac Button");
    }
}

public class WindowsCheckbox implements Checkbox {
    public void paint() {
        System.out.println("Rendered Windows Checkbox");
    }
}

public class MacCheckbox implements Checkbox {
    public void paint() {
        System.out.println("Rendered Mac Checkbox");
    }
}

Abstract Factory

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

Concrete Factories

public class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

public class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

Client Code

public class Application {
    private Button button;
    private Checkbox checkbox;

    public Application(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }

    public void render() {
        button.paint();
        checkbox.paint();
    }
}

Application Runner

public class Demo {
    public static void main(String[] args) {
        GUIFactory factory;

        String osName = System.getProperty("os.name").toLowerCase();

        if (osName.contains("mac")) {
            factory = new MacFactory();
        } else {
            factory = new WindowsFactory();
        }

        Application app = new Application(factory);
        app.render();
    }
}

When to Use Abstract Factory

Advantages

1. Consistency Across Products
   Ensures all related objects work well together.

2. Encapsulation of Object Creation
   Client is decoupled from specific classes.

3. Scalability
   Adding a new family of objects is easy—just create a new factory.

4. Code Flexibility
   Helps support different configurations (themes, OS) at runtime.

Disadvantages

1. Complex Structure
   Involves multiple interfaces and classes, which may feel like over-engineering for small apps.

2. Rigid Design
   Adding a new product type requires changes in all factory classes.

3. Too Abstract
   Might be hard to trace instantiation if overused in large codebases.

Why Use Abstract Factory

Why Not Use It?

• You only need one type of object? Use Factory Method.
• Adding new product types frequently? Consider Builder or Dependency Injection.
• Small/simple system? Abstract Factory may be overkill.

Alternative Patterns

Conclusion

The Abstract Factory Pattern is a powerful design pattern that ensures consistency, decouples product creation, and enables scalable architectures. When used appropriately, it can significantly improve code maintainability and flexibility.

However, with great power comes great responsibility. Avoid it if your application is small or product families are unlikely to grow.

Great! Since you're working with both Factory Method and Abstract Factory, it's important to understand how they're related yet distinct.

Factory Method vs Abstract Factory Detailed Comparison

✅ Factory Method – Summary

A single factory class with a method that returns a single object type, usually using inheritance.

🔧 Example:

public interface Employee {
    void work();
}

public class WebDeveloper implements Employee {
    public void work() {
        System.out.println("Web development work");
    }
}

public class AndroidDeveloper implements Employee {
    public void work() {
        System.out.println("Android development work");
    }
}

public class EmployeeFactory {
    public static Employee getEmployee(String type) {
        if (type.equalsIgnoreCase("WEB")) return new WebDeveloper();
        if (type.equalsIgnoreCase("ANDROID")) return new AndroidDeveloper();
        throw new IllegalArgumentException("Unknown employee type");
    }
}

🧱 Abstract Factory – Summary

A super-factory that creates other factories, each responsible for a group of related products.

🔧 Example:

// Products
interface Button { void render(); }
interface TextBox { void display(); }

// Concrete Products
class WindowsButton implements Button { public void render() { System.out.println("Windows Button"); } }
class MacButton implements Button { public void render() { System.out.println("Mac Button"); } }

class WindowsTextBox implements TextBox { public void display() { System.out.println("Windows TextBox"); } }
class MacTextBox implements TextBox { public void display() { System.out.println("Mac TextBox"); } }

// Abstract Factory
interface GUIFactory {
    Button createButton();
    TextBox createTextBox();
}

// Concrete Factories
class WindowsFactory implements GUIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextBox createTextBox() { return new WindowsTextBox(); }
}

class MacFactory implements GUIFactory {
    public Button createButton() { return new MacButton(); }
    public TextBox createTextBox() { return new MacTextBox(); }
}

🧠 Key Differences in Summary

📌 When to Use What?

📚 Visual Summary

Factory Method:
  [Creator]
      |
  +---+---+
  |       |
[WebDev] [AndroidDev]

Abstract Factory:
             [AbstractFactory]
               /          \
      [WinFactory]      [MacFactory]
       /     \           /          \
    [Button][Textbox]  [Button].  [Textbox]

📚 Explore More Design Patterns in Java

• 🔒 Mastering the Singleton Design Pattern in Java – A Complete Guide
• ⚠️ Why You Should Avoid Singleton Pattern in Modern Java Projects
• 🏭 Factory Design Pattern in Java – A Complete Guide
• 🧱 Builder Design Pattern in Java – A Complete Guide
• 👀 Observer Design Pattern in Java – Complete Guide
• 🔁 Iterator Design Pattern in Java – Complete Guide
• 🔌 Adapter Design Pattern in Java – A Complete Guide

More Details:

Get all articles related to system design
Hastag: SystemDesignWithZeeshanAli

systemdesignwithzeeshanali

Git: https://github.com/ZeeshanAli-0704/SystemDesignWithZeeshanAli