Hvad er Factory-mønsteret?

Question

Accepted Answer

**Factory**-mønsteret giver en måde at **skabe objekter uden at specificere deres eksakte klasse** — en metode eller klasse, der håndterer objektoprettelse og beslutter, hvilken type der skal instantieres. Det centraliser og abstraherer objektoprettelse, hvilket løskoblet kode fra konkrete klasser.

## Hvad Factory-mønsteret gør

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

## Eksempel

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

## Fordele og variationer

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

## Hvorfor det betyder noget

At forstå Factory-mønsteret er værdifuldt, fordi det er et **hyppigt, brugbart kreativt mønster** til at løskoblet kode fra objektoprettelse, så det er praktisk relevant designviden.

Factory-mønsteret indkapsler objektoprettelse — en factory-metode eller klasse beslutter, hvilken klasse der skal instantieres, så opkaldere beder om et objekt (efter type eller parameter) og får det rigtige **uden at kende eller specificere den konkrete klasse**.

At forstå dette er værdifuldt, fordi det adresserer et rigtigt behov: **løskoblet kode fra konkrete klasser** (opkaldere afhænger af factory'en/interfacet snarere end specifikke implementeringer) og **centralisering af oprettelseslogik** (på ét sted, hvilket gør det nemmere at ændre og udvide).

At forstå **fordelene** — løskobling, centraliseret oprettelse og fleksibilitet (nemt at tilføje nye typer ved at ændre factory'en eller bytte implementeringer uden at ændre al kaldekoden) — præciserer, hvorfor mønsteret er brugbart for vedligeholdbar, fleksibel kode.

At forstå **variationerne** — den simple factory (en metode, der beslutter hvad der skal oprettes), **factory method** (ofte overrides af underklasser) og **abstract factory** (skaber familier af relaterede objekter) — dækker spektret af factory-tilgange.

Factory-mønsteret bruges almindeligt og diskuteres hyppigt, dukker op gennem rigtige kodebase og frameworks, hvor objektoprettelse skal være fleksibel eller løstkoblet.

Da Factory-mønsteret er et hyppigt, brugbart kreativt mønster til at løskoblet kode fra objektoprettelse og centralisering af oprettelseslogik (forbedrer fleksibilitet og vedligeholdbarhed), og da det at forstå hvad det gør, dets fordele og variationer er praktisk relevant, er det at forstå Factory-mønsteret værdifuldt, almindeligt anvendeligt designviden — et hyppigt brugt kreativt mønster til løskobling og fleksibilitet i objektoprettelse, almindeligt i rigtige kodebase og frameworks, og vigtig designviden for at skrive vedligeholdbar, fleksibel kode.