Welche häufigen Design Patterns gibt es in Java?

Question

Accepted Answer

**Design Patterns** sind wiederverwendbare Lösungen für wiederkehrende Softwaredesign-Probleme. Javas OOP-Natur und Ökosystem machen mehrere Patterns besonders häufig — sie zu kennen hilft dir, bewährte Strukturen zu erkennen, zu kommunizieren und anzuwenden. Sie fallen in kreative, strukturelle und verhaltensorientierte Kategorien.

## Singleton (creational) — eine gemeinsame Instanz

```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) — Objekterstellung kapseln

```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) — komplexe Objekte Schritt für Schritt konstruieren

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

## Strategy (behavioral) — austauschbare Algorithmen

```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) — umhüllen, um Verhalten hinzuzufügen

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

## Wo Patterns in Java selbst erscheinen

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

## Eine Warnung vor Übernutzung

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

## Warum es wichtig ist

Design Patterns bieten ein gemeinsames Vokabular und bewährte Lösungen für häufige Designprobleme, was wertvoll für Kommunikation ist ("nutze hier ein Strategy"), das Erkennen von Strukturen in vorhandenem Code und das Vermeiden, fehlerhafte Lösungen neu zu erfinden.

Sie erscheinen überall in Javas eigenen Bibliotheken (I/O-Dekoratoren, Factory-Methoden, Builder, Observer-basierte Events), daher hilft dir das Verständnis dafür, die Standardbibliothek effektiv zu nutzen und zu erweitern.

Die wichtigsten Patterns zu kennen — Singleton, Factory, Builder, Strategy, Observer, Decorator — und zu wissen, wo jedes passt, ist ein Kennzeichen erfahrener Entwickler und ein häufiges Interviewthema.

Gleich wichtig ist die Urteilskraft, sie angemessen anzuwenden (echte Probleme lösen), anstatt sie zu erzwingen, besonders da moderne Features wie Lambdas viele klassische Patterns vereinfachen.