Welke veelvoorkomende design patterns verschijnen in Java?

Question

Accepted Answer

**Design patterns** zijn herbruikbare oplossingen voor terugkerende softwareontwerp-problemen. Java's OOP-karakter en ecosysteem maken verschillende patterns vooral gebruikelijk — het kennen ervan helpt je om beproefde structuren te herkennen, uit te wisselen en toe te passen. Ze vallen in drie categorieën: creational, structural en behavioral.

## Singleton (creational) — één gedeeld exemplaar

```java
public class Config {
    private static final Config INSTANCE = new Config();   // the single instance
    private Config() {}                                     // private constructor
    public static Config getInstance() { return INSTANCE; }
}
// (enum singletons are an even safer idiom). Used for shared config, connection pools.
```

## Factory (creational) — objectcreatie inkapselen

```java
public static Shape createShape(String type) {
    return switch (type) {                 // hides the concrete class from the caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller depends on Shape, not concrete classes — decoupling.
```

## Builder (creational) — complexe objecten stap voor stap construeren

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // readable construction; avoids huge telescoping constructors
```

## Strategy (behavioral) — uitwisselbare algoritmen

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// swap behavior at runtime — lambdas make this trivial in modern Java
processor.setStrategy(new PayPal());
```

## Observer (behavioral) — publish/subscribe

```java
// subjects notify registered observers of changes (events, listeners)
button.addActionListener(e -> handleClick());   // GUI events use this everywhere
```

## Decorator (structural) — omwikkelen om gedrag toe te voegen

```java
// Java's I/O streams ARE the decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader wraps FileReader, adding buffering
```

## Waar patterns in Java zelf voorkomen

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listeners, java.util.Observer
Decorator  → java.io streams (BufferedReader wrapping FileReader)
Iterator   → the Iterator interface / Collections
Strategy   → Comparator, functional interfaces
```

## Een waarschuwing tegen overgebruik

```text
Patterns are tools, not goals. Applying them where they don't fit ADDS complexity.
Use them when they genuinely solve your problem — many can be simpler with lambdas now.
```

## Waarom het belangrijk is

Design patterns bieden een gedeelde woordenschat en beproefde oplossingen voor veelvoorkomende ontwerpkwesties, wat waardevol is voor communicatie ("gebruik hier een Strategy"), het herkennen van structuren in bestaande code en het vermijden van het herbronnen van gebrekkige oplossingen.

Ze verschijnen overal in Java's eigen bibliotheken (I/O-decorators, factory-methoden, builders, observer-gebaseerde events), dus het begrijpen ervan helpt je de standaardbibliotheek effectief te gebruiken en uit te breiden.

Het kennen van de grote patterns — Singleton, Factory, Builder, Strategy, Observer, Decorator — en waar elk van toepassing is, is een kenmerk van ervaren developers en een veelvoorkomend interview-onderwerp.

Evenals belangrijk is het inzicht om ze op passende wijze toe te passen (werkelijke problemen oplossen) in plaats van ze in te forceren, vooral gezien moderne features zoals lambda's veel klassieke patterns vereenvoudigen.