Abstract Factory pattern

Overview

Abstract Factory provides an interface for creating families of related objects without specifying their concrete classes. A UIFactory creates a Button, a Checkbox, and a Dialog that all match the same theme or platform. The client picks one factory, and every product it creates is guaranteed to be compatible.

Factory Method creates one product and lets subclasses decide which; Abstract Factory groups several factory methods so a whole family changes together. It shines when mixing products from different families would be a bug: a dark button with a light dialog, or an AWS queue with an Azure blob client.

When to use it

• Several related objects must be created consistently (theme, platform, vendor).
• The family is chosen once at startup or per tenant.
• Clients should not know concrete classes.

Where it shows up in interviews

Where it is used in real software

Key terms

Abstract factory

Interface with create methods for each product.

Concrete factory

Implements all create methods for one family.

Product family

Objects designed to work together.

Abstract product

Interface for each product type.

How it works, step by step

1. 1
   List product types

   Button, Checkbox, Dialog.

2. 2
   Define product interfaces

   One per type.

3. 3
   Define the factory interface

   createButton(), createCheckbox().

4. 4
   Implement a factory per family

   LightThemeFactory, DarkThemeFactory.

5. 5
   Choose the factory once

   At the composition root; pass it to clients.

Theme factories

Clients call factory.createButton() and factory.createDialog()

Adding a family is a new factory; adding a new product type requires changing every factory (the pattern's main trade-off).

Implementation

1interface Button { render(): string }2interface Dialog { render(body: string): string }3 4interface UIFactory {5  createButton(label: string): Button;6  createDialog(): Dialog;7}8 9class DarkFactory implements UIFactory {10  createButton(label: string): Button { return { render: () => `[dark-btn ${label}]` }; }11  createDialog(): Dialog { return { render: (b) => `<dark-dialog>${b}</dark-dialog>` }; }12}13 14class LightFactory implements UIFactory {15  createButton(label: string): Button { return { render: () => `[light-btn ${label}]` }; }16  createDialog(): Dialog { return { render: (b) => `<light-dialog>${b}</light-dialog>` }; }17}18 19function confirmScreen(ui: UIFactory) {20  return ui.createDialog().render(ui.createButton("OK").render()); // always consistent21}22 23confirmScreen(prefersDark ? new DarkFactory() : new LightFactory());

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Using it for a single product.

  Fix: Use Factory Method or a simple function.

• Clients still instantiating some concrete products.

  Fix: Route all creation through the factory to keep families consistent.

Interview questions

Practice problems