Wanneer moet je een factory method gebruiken in plaats van een constructor?

Question

Accepted Answer

Een **constructor** retourneert altijd een gloednieuw exemplaar van *zijn exact class*, met een naam die vastgesteld is aan de class. Een **factory method** is een reguliere (vaak static) methode die objecten creëert — waardoor je vrijheid krijgt over *naamgeving*, *welk subtype* je teruggeeft, en *of* je überhaupt een nieuw object maakt.

## Wat een factory kan doen dat een constructor niet kan

```java
public class Color {
    private final int r, g, b;
    private Color(int r, int g, int b) { this.r=r; this.g=g; this.b=b; }

// Named factories: clearer intent than overloaded constructors
    public static Color fromRgb(int r, int g, int b) { return new Color(r,g,b); }
    public static Color fromHex(String hex) { /* parse */ return new Color(0,0,0); }

// Can return a CACHED instance instead of always allocating
    private static final Color BLACK = new Color(0,0,0);
    public static Color black() { return BLACK; }   // no 'new' every call
}
```

## Constructor versus factory method

| | Constructor | Factory method |
|---|---|---|
| Naam | Vastgesteld aan class | Beschrijvend (`fromHex`) |
| Retourtype | Exact deze class | Elk subtype / interface |
| Identiteit | Altijd nieuw | Kan cachen/pooling/hergebruik |
| Kan netjes mislukken | Werpt uitzondering | Kan null/Optional retourneren |

```java
Optional<User> u = User.tryParse(json);   // a constructor can't return Optional
```

## Valkuil

Factories voegen indirection toe en kunnen verbergen wat werkelijk geconstrueerd wordt. Gebruik een gewone constructor voor eenvoudige waardecreatie; grijp naar een factory als je naamgeving, polymorfische returns of instance control nodig hebt.

## Waarom het belangrijk is

Factory methods ontkoppelen aanroepers van concrete classes — je kunt een andere implementatie of een cached instance retourneren zonder call sites aan te passen.

Ze maken API's ook duidelijker: `Color.fromHex("#fff")` leest beter dan een constructor overload, en named factories omzeilen de ambiguïteit van meerdere constructoren met dezelfde types.

	Constructor	Factory method
Naam	Vastgesteld aan class	Beschrijvend (`fromHex`)
Retourtype	Exact deze class	Elk subtype / interface
Identiteit	Altijd nieuw	Kan cachen/pooling/hergebruik
Kan netjes mislukken	Werpt uitzondering	Kan null/Optional retourneren