Was ist das Factory-Pattern?

Question

Accepted Answer

Das **Factory**-Pattern bietet eine Möglichkeit, **Objekte zu erstellen, ohne ihre exakte Klasse anzugeben** — eine Methode oder Klasse, die die Objekterstellung handhabt und entscheidet, welcher Typ instantiiert werden soll. Es zentralisiert und abstrahiert die Objekterstellung und entkoppelt Code von konkreten Klassen.

## Was das Factory-Pattern bewirkt

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

## Beispiel

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

## Vorteile und Variationen

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

## Warum es wichtig ist

Das Verständnis des Factory-Patterns ist wertvoll, weil es ein **häufiges und nützliches Erzeugungsmuster** zur Entkopplung von Code von der Objekterstellung ist und daher praktisch relevantes Design-Wissen darstellt.

Das Factory-Pattern kapselt die Objekterstellung ein — eine Factory-Methode oder -Klasse entscheidet, welche Klasse instantiiert werden soll, so dass Aufrufer ein Objekt anfordern (nach Typ oder Parameter) und das richtige erhalten, **ohne die konkrete Klasse zu kennen oder anzugeben**.

Dieses Verständnis ist wertvoll, weil es ein echtes Bedürfnis adressiert: **Code von konkreten Klassen entkoppeln** (Aufrufer hängen von der Factory/dem Interface ab, nicht von spezifischen Implementierungen) und **Erstellungslogik zentralisieren** (an einem Ort, was es einfacher macht zu ändern und zu erweitern).

Das Verständnis der **Vorteile** — Entkopplung, zentralisierte Erstellung und Flexibilität (einfaches Hinzufügen neuer Typen durch Änderung der Factory oder Austausch von Implementierungen, ohne all den aufrufenden Code zu modifizieren) — verdeutlicht, warum das Pattern für wartbaren, flexiblen Code nützlich ist.

Das Verständnis der **Variationen** — die einfache Factory (eine Methode, die entscheidet, was zu erstellen ist), die **Factory Method** (oft von Subklassen überschrieben) und die **Abstract Factory** (Erstellung von Familien verwandter Objekte) — deckt das Spektrum der Factory-Ansätze ab.

Das Factory-Pattern wird häufig verwendet und regelmäßig diskutiert, erscheint überall in echten Codebasen und Frameworks, wo die Objekterstellung flexibel oder entkoppelt sein muss.

Da das Factory-Pattern ein häufiges, nützliches Erzeugungsmuster zur Entkopplung von Code von der Objekterstellung und Zentralisierung der Erstellungslogik ist (was Flexibilität und Wartbarkeit verbessert), und da das Verständnis dessen, was es bewirkt, seiner Vorteile und seiner Variationen praktisch relevant ist, stellt das Verständnis des Factory-Patterns wertvoles, häufig anwendbares Design-Wissen dar — ein häufig verwendetes Erzeugungsmuster für Entkopplung und Flexibilität bei der Objekterstellung, verbreitet in echten Codebasen und Frameworks, und wichtiges Design-Wissen zum Schreiben von wartbarem, flexiblem Code.