Kateri pogosti oblikovni vzorci se pojavljajo v Javi?

Question

Accepted Answer

**Oblikovni vzorci** so znova uporabne rešitve za ponavljajoče se probleme pri oblikovanju programske opreme. Narava Jave, osredotočena na OOP, in njena ekosistema delajo več vzorcev posebej pogostih — njihovo poznavanje vam pomaga prepoznati, oblikovati in uporabiti dokazane strukture. Delijo se na vzorce za kreiranje, strukturne in vedenjske vzorce.

## Singleton (kreiranje) — ena deljena instanca

```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 (kreiranje) — inkapsuliraj kreiranje objektov

```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 (kreiranje) — sestavi zapletene objekte korak za korakom

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

## Strategy (vedenjski) — zamenljivi algoritmi

```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 (vedenjski) — objavi/naroči se

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

## Decorator (strukturni) — zavij, da dodam vedenje

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

## Kje se vzorci pojavljajo v Javi sami

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

## Opozorilo pred preuporabo

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

## Zakaj je to pomembno

Oblikovni vzorci zagotavljajo skupni besednjak in dokazane rešitve za običajne probleme pri oblikovanju, kar je dragoceno za komunikacijo ("uporabi Strategy tukaj"), prepoznavanje struktur v obstoječem kodu in izogibanje ponovnemu izumljanju napačnih rešitev.

Pojavljajo se v celotnih Javinih knjižnicah (I/O dekoratorji, tovarniške metode, gradniki, vedenja, ki temeljijo na opazovalcih), zato njihovo razumevanje pomaga pri učinkoviti rabi in razширitvi standardne knjižnice.

Poznavanje glavnih vzorcev — Singleton, Factory, Builder, Strategy, Observer, Decorator — in njihove primere je značilnost izkušenih razvijalcev in pogost intervjuski problem.

Enako pomembna je presoja, da jih uporabite primerno (reševanje resničnih problemov) namesto da jih vsilite, posebej ker moderne lastnosti, kot so lambda izrazi, poenostavijo marsikatere klasične vzorce.