Factory Pattern — Factory Method & Abstract Factory (2026)

In this tutorial, you'll learn the three variations of the factory pattern — simple factory, factory method, and abstract factory — how each one solves object creation problems, and when to choose one over the other.

A car factory doesn't hand-assemble every vehicle from scratch. It has specialized assembly lines: one for sedans, one for SUVs, one for electric vehicles. Each line knows exactly how to build its type of car. You tell the factory "I need an SUV," and it routes your order to the right line. You don't build the car yourself — you delegate creation to the factory. In software, factory patterns do the same for object creation.

Core Concept

Factory patterns centralize object creation, hiding the instantiation logic from the client. They come in three levels of complexity:

Simple Factory

A simple factory is a single function that returns different object types based on input:

// Simple Factory
function createLogger(type: "console" | "file" | "cloud"): Logger {
  switch (type) {
    case "console":
      return new ConsoleLogger();
    case "file":
      return new FileLogger("/var/log/app.log");
    case "cloud":
      return new CloudLogger("log-storage-123");
    default:
      throw new Error(`Unknown logger type: ${type}`);
  }
}

// Usage
const logger = createLogger("file");
logger.info("Application started");

Factory Method

The factory method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate:

// Factory Method — base class with abstract factory method
abstract class DocumentExporter {
  // The factory method — subclasses override this
  protected abstract createExporter(): Exporter;

  export(data: Record<string, unknown>): void {
    const exporter = this.createExporter();
    exporter.connect();
    exporter.write(data);
    exporter.close();
  }
}

// Concrete creators override the factory method
class PdfExporter extends DocumentExporter {
  protected createExporter(): Exporter {
    return new PdfLibExporter();
  }
}

class CsvExporter extends DocumentExporter {
  protected createExporter(): Exporter {
    return new CsvStreamExporter();
  }
}

// Usage
const exporter: DocumentExporter = new PdfExporter();
exporter.export({ title: "Report", data: [1, 2, 3] });
// Uses PdfLibExporter internally — client doesn't know

Abstract Factory

The abstract factory pattern creates families of related objects without specifying their concrete classes:

// Abstract Factory interface
interface UIFactory {
  createButton(): Button;
  createTextInput(): TextInput;
  createCheckbox(): Checkbox;
}

// Concrete factory for dark theme
class DarkThemeFactory implements UIFactory {
  createButton(): Button {
    return new DarkButton();
  }
  createTextInput(): TextInput {
    return new DarkTextInput();
  }
  createCheckbox(): Checkbox {
    return new DarkCheckbox();
  }
}

// Concrete factory for light theme
class LightThemeFactory implements UIFactory {
  createButton(): Button {
    return new LightButton();
  }
  createTextInput(): TextInput {
    return new LightTextInput();
  }
  createCheckbox(): Checkbox {
    return new LightCheckbox();
  }
}

// Usage — client only depends on the factory interface
function renderUI(factory: UIFactory) {
  const button = factory.createButton();
  const input = factory.createTextInput();
  const checkbox = factory.createCheckbox();
  // Render all components — they'll be consistently themed
}

┌──────────────────────────────────────┐
│          Abstract Factory            │
│  + createButton(): Button            │
│  + createTextInput(): TextInput      │
│  + createCheckbox(): Checkbox        │
└──────────────────────────────────────┘
           ↑                ↑
┌──────────────────┐  ┌──────────────────┐
│ DarkThemeFactory │  │LightThemeFactory │
├──────────────────┤  ├──────────────────┤
│ createButton()   │  │ createButton()   │
│ createTextInput()│  │ createTextInput()│
│ createCheckbox() │  │ createCheckbox() │
└──────────────────┘  └──────────────────┘

Expected output: The client gets a consistent set of UI components without knowing which theme is active. Switching themes means passing a different factory — zero changes to rendering code.

Real-World Examples

Database Driver Selection

DodaZIP uses an abstract factory to support different storage backends. The StorageFactory interface defines methods for createReader, createWriter, and createLister. Concrete factories (S3StorageFactory, LocalStorageFactory, GCSStorageFactory) implement each method. Adding a new backend means writing one new factory class.

Cross-Platform UI

Abstract factory is the foundation of cross-platform UI toolkits. A WidgetFactory creates buttons, windows, and menus. The WindowsFactory returns Windows-native widgets. The MacFactory returns macOS-native widgets. The same application code works on both platforms.

Factory vs Dependency Injection

They're not mutually exclusive — a factory can be registered with a DI container.

Pros & Cons

When to Use

Use the simple factory when you have one creation point with conditional logic. Use factory method when subclasses need to control which objects they create. Use abstract factory when you need to create families of related objects that must be consistent.

Skip factories entirely when a simple new statement suffices, the object has no variants, or a DI container handles creation naturally.

FAQ