Wat is het Factory-patroon?

Question

Accepted Answer

Het **Factory**-patroon biedt een manier om **objecten te maken zonder hun exacte klasse op te geven** — een methode of klasse die object creatie afhandelt en beslist welk type geïnstantieerd moet worden. Het centraliseert en abstraheert object creatie, waarbij code wordt ontkoppeld van concrete klassen.

## Wat het Factory-patroon doet

```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
```

## Voorbeeld

```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
```

## Voordelen en variaties

```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
```

## Waarom het belangrijk is

Het Factory-patroon begrijpen is waardevol omdat het een **common, nuttig creatief patroon** is voor het ontkoppelen van code van object creatie, dus het is praktisch relevante design kennis.

Het Factory-patroon encapsuleert object creatie — een factory methode of klasse beslist welke klasse geïnstantieerd moet worden, zodat callers een object aanvragen (naar type of parameter) en de juiste krijgen **zonder de concrete klasse te kennen of op te geven**.

Dit begrijpen is waardevol omdat het een echte behoefte adresseert: **code ontkoppelen van concrete klassen** (callers hangen af van de factory/interface in plaats van specifieke implementaties) en **creatie logica centraliseren** (op één plek, waardoor het gemakkelijker wordt om te veranderen en uit te breiden).

Het begrijpen van de **voordelen** — ontkoppeling, gecentraliseerde creatie, en flexibiliteit (gemakkelijk nieuwe types toevoegen door de factory te wijzigen, of implementaties uit te wisselen, zonder alle roepende code aan te passen) — verduidelijkt waarom het patroon nuttig is voor onderhoudbare, flexibele code.

Het begrijpen van de **variaties** — de simple factory (een methode die beslist wat te creëren), de **factory method** (vaak overschreven door subklassen), en de **abstract factory** (het creëren van families van gerelateerde objecten) — dekt het spectrum van factory-benaderingen.

Het Factory-patroon wordt veel gebruikt en regelmatig besproken, en verschijnt overal in echte codebases en frameworks waar object creatie flexibel of ontkoppeld moet zijn.

Omdat het Factory-patroon een common, nuttig creatief patroon is voor het ontkoppelen van code van object creatie en het centraliseren van creatie logica (verbetering van flexibiliteit en onderhoudbaarheid), en omdat het begrijpen wat het doet, de voordelen, en de variaties praktisch relevant is, is het begrijpen van het Factory-patroon waardevol, algemeen toepasbare design kennis — een veel gebruikt creatief patroon voor ontkoppeling en flexibiliteit in object creatie, common in echte codebases en frameworks, en belangrijke design kennis voor het schrijven van onderhoudbare, flexibele code.