Vilka vanliga designmönster förekommer i Java?

Question

Accepted Answer

**Designmönster** är återanvändbara lösningar på återkommande mjukvarudesignproblem. Javas OOP-natur och ekosystem gör flera mönster särskilt vanliga — att känna till dem hjälper dig att känna igen, kommunicera och tillämpa väl beprövade strukturer. De delas in i skapande, strukturella och beteenderelaterade kategorier.

## Singleton (skapande) — en delad instans

```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 (skapande) — kapsla in objektskapandet

```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 (skapande) — konstruera komplexa objekt steg för steg

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

## Strategy (beteenderelaterad) — utbytbara algoritmer

```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 (beteenderelaterad) — publicera/prenumerera

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

## Decorator (strukturell) — slå in för att lägga till beteende

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

## Där mönster förekommer i Java själv

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

## En varning mot överanvändning

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

## Varför det spelar roll

Designmönster tillhandahåller ett gemensamt ordförråd och beprövade lösningar på vanliga designproblem, vilket är värdefullt för kommunikation ("använd ett Strategy här"), igenkänning av strukturer i befintlig kod och undvikande av att uppfinna felaktiga lösningar på nytt.

De förekommer i hela Javas bibliotek (I/O-dekoratörer, fabriksmetoder, byggare, observatörsbaserade händelser), så förståelse för dem hjälper dig att använda och utöka standardbiblioteket effektivt.

Att känna till de viktigaste mönstren — Singleton, Factory, Builder, Strategy, Observer, Decorator — och där var och en passar är ett kännetecken på erfarna utvecklare och ett ofta förekommande intervjuämne.

Lika viktigt är omdömet att tillämpa dem lämpligt (lösa verkliga problem) snarare än att tvinga in dem, särskilt eftersom moderna funktioner som lambdor förenklar många klassiska mönster.