What is the Factory pattern?

Question

Accepted Answer

The **Factory** pattern provides a way to **create objects without specifying their exact class** — a method or class that handles object creation, deciding which type to instantiate. It centralizes and abstracts object creation, decoupling code from concrete classes.

## What the Factory pattern does

```text
FACTORY → encapsulate object CREATION (instead of calling constructors directly):
  → a factory method/class decides WHICH class to instantiate and creates it
  → the caller asks the factory for an object (by type/parameter) → gets the right object
    WITHOUT knowing/specifying the concrete class
→ decouples code from CONCRETE classes; centralizes creation logic
```

## Example

```js
// a factory creates the right type based on input
class ShapeFactory {
  static create(type) {
    switch (type) {
      case 'circle': return new Circle();
      case 'square': return new Square();
      default: throw new Error('Unknown shape');
    }
  }
}
const shape = ShapeFactory.create('circle');   // caller doesn't use 'new Circle' directly
// → to add a new shape, change the factory, not all the calling code
```

## Benefits and variations

```text
BENEFITS:
  ✓ DECOUPLING → callers depend on an interface/factory, not concrete classes
  ✓ CENTRALIZED creation → creation logic in one place (easier to change/extend)
  ✓ FLEXIBILITY → easy to add new types (change the factory) or swap implementations
VARIATIONS:
  → FACTORY METHOD → a method (often overridden by subclasses) creates objects
  → ABSTRACT FACTORY → creates families of related objects
  → simple factory (as above) is the basic form
```

## Why it matters

Understanding the Factory pattern is valuable because it's a **common, useful creational pattern** for decoupling code from object creation, so it's practically-relevant design knowledge.

The Factory pattern encapsulates object creation — having a factory method or class decide which class to instantiate, so callers ask for an object (by type or parameter) and get the right one **without knowing or specifying the concrete class**.

Understanding this is valuable because it addresses a real need: **decoupling code from concrete classes** (callers depend on the factory/interface rather than specific implementations) and **centralizing creation logic** (in one place, making it easier to change and extend).

Understanding the **benefits** — decoupling, centralized creation, and flexibility (easily adding new types by changing the factory, or swapping implementations, without modifying all the calling code) — clarifies why the pattern is useful for maintainable, flexible code.

Understanding the **variations** — the simple factory (a method deciding what to create), the **factory method** (often overridden by subclasses), and the **abstract factory** (creating families of related objects) — covers the spectrum of factory approaches.

The Factory pattern is commonly used and frequently discussed, appearing throughout real codebases and frameworks wherever object creation needs to be flexible or decoupled.

Since the Factory pattern is a common, useful creational pattern for decoupling code from object creation and centralizing creation logic (improving flexibility and maintainability), and since understanding what it does, its benefits, and its variations is practically relevant, understanding the Factory pattern is valuable, commonly-applicable design knowledge — a frequently-used creational pattern for decoupling and flexibility in object creation, common in real codebases and frameworks, and important design knowledge for writing maintainable, flexible code.