Vad är Factory-mönstret?

Question

Accepted Answer

**Factory**-mönstret ger ett sätt att **skapa objekt utan att ange deras exakta klass** — en metod eller klass som hanterar objektskapande och bestämmer vilken typ som ska instansieras. Det centraliserar och abstraherar objektskapande, vilket decoupler kod från konkreta klasser.

## Vad Factory-mönstret 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
```

## Exempel

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

## Fördelar och 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
```

## Varför det är viktigt

Att förstå Factory-mönstret är värdefullt eftersom det är ett **vanligt, användbart skapande-mönster** för att decoupler kod från objektskapande, så det är praktiskt relevant designkunskap.

Factory-mönstret kapslar in objektskapande — en fabriksmetod eller klass bestämmer vilken klass som ska instansieras, så anropare frågar efter ett objekt (efter typ eller parameter) och får rätt en **utan att veta eller ange den konkreta klassen**.

Att förstå detta är värdefullt eftersom det adresserar ett verkligt behov: **decoupling av kod från konkreta klasser** (anropare beror på fabriken/interfacet snarare än specifika implementeringar) och **centralisering av skapandelogik** (på ett ställe, vilket gör det lättare att ändra och utöka).

Att förstå **fördelarna** — decoupling, centraliserad skapande och flexibilitet (enkelt att lägga till nya typer genom att ändra fabriken, eller byta implementeringar, utan att ändra all anropkod) — förtydligar varför mönstret är användbart för underhållbar, flexibel kod.

Att förstå **variationerna** — den enkla fabriken (en metod som bestämmer vad som ska skapas), **factory method** (ofta överskuggas av subklasser) och **abstract factory** (skapande av relaterade objektfamiljer) — täcker spektrumet av fabriksmetoder.

Factory-mönstret används ofta och diskuteras ofta, förekommer i hela riktiga kodbasar och ramverk överallt där objektskapande måste vara flexibelt eller decoupled.

Eftersom Factory-mönstret är ett vanligt, användbart skapande-mönster för att decoupler kod från objektskapande och centralisera skapandelogik (förbättrar flexibilitet och underhållbarhet), och eftersom att förstå vad det gör, dess fördelar och dess variationer är praktiskt relevant, är att förstå Factory-mönstret värdeful, allmänt tillämpbar designkunskap — ett ofta använt skapande-mönster för decoupling och flexibilitet i objektskapande, vanligt i riktiga kodbasar och ramverk, och viktigt designkunskap för att skriva underhållbar, flexibel kod.