Kokie yra bendri Java dizaino šablonai?

Question

Accepted Answer

**Dizaino šablonai** yra pakartotinai naudojami sprendimai pasikartojančioms programinės įrangos projektavimo problemoms. Java OOP pobūdis ir ekosistema daro kelis šablonus ypač paprastais — jų pažinimas padeda juos atpažinti, komunikuoti ir taikyti patvirtintus struktūrus. Jie skirstomi į kūriamuosius, struktūrinius ir elgesio kategorijas.

## Singleton (kuriamasis) — viena bendrinta instancija

```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 (kuriamasis) — objekto kūrimo išorinimas

```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 (kuriamasis) — sudėtingų objektų kūrimas žingsnis po žingsnio

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

## Strategy (elgesys) — keičiami algoritmai

```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 (elgesys) — skelbimas/prenumerata

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

## Decorator (struktūrinis) — apvyniojimas elgesio pridėjimui

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

## Kur šablonai pasirodo pačioje Java

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

## Perspėjimas dėl per didelio naudojimo

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

## Kodėl tai svarbu

Dizaino šablonai suteikia bendrą žodyną ir patvirtintus sprendimus dėl įprastų projektavimo problemų, kas yra naudinga komunikacijai ("naudokite Strategy čia"), esamo kodo struktūrų atpažinimui ir klaidingų sprendimų iš naujo išradi vengimo.

Jie pasirodo per visą Java standartinę biblioteką (I/O dekoratorus, gamyklos metodus, statytojus, stebėtojo pagrįstus įvykius), todėl jų supratimas padeda efektyviai naudoti ir pratęsti standartinę biblioteką.

Pagrindinio šablono pažinimas — Singleton, Factory, Builder, Strategy, Observer, Decorator — ir tai, kur kiekvienas tinka, yra patyrių kūrėjų ženklas ir dažna pokalbio tema.

Tolygiai svarbu ir sprendimas juos taikyti atitinkamai (sprendžiant tikras problemas), o ne juos priverstinai naudoti, ypač nes šiuolaikinės funkcijos, tokios kaip lambdos, supaprastina daugelį klasikinių šablonų.