Apa pola desain umum sing ana ing Java?

Question

Accepted Answer

**Pola desain** yaiku solusi sing bisa digunakake maneh kanggo masalah desain software sing muncul boyan-boyan. Sifat OOP Java lan ekosistem e ndadekake pirang pola sing khusus umum — ngerti tentang iki membantu ngakoni, komunikasi, lan terapake struktur sing wis kabukti. Pola-pola iki terbagi dadi kategori kreatif, struktural, lan perilaku.

## Singleton (kreatif) — siji instans sing dibarengi

```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 (kreatif) — ngapsulasi pembuatan obyek

```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 (kreatif) — nggawe obyek kompleks kanthi materi-materi

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

## Strategy (perilaku) — algoritma sing bisa digatekake

```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 (perilaku) — publish/subscribe

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

## Decorator (struktural) — mbungkus kanggo nambah perilaku

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

## Endi pola-pola iki muncul ing Java dhewe

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

## Kadohanan bab panganggone sing berlebihan

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

## Mengapa iki penting

Pola desain menerangake kosakata sing dibarengi lan solusi sing wis kabukti kanggo masalah desain umum, kang iki migunani kanggo komunikasi ("gunakake Strategy kene"), ngakoni struktur ing kode sing ana, lan ngindhari nggawe maneh solusi sing cacat.

Pola-pola iki muncul ing kabeh perpustakaan standar Java (dekorator I/O, metode pabrik, pembangun, acara basis pengamat), dadi paham iki tumutulung sampeyan nggunakake lan ngembangake perpustakaan standar kanthi efektif.

Ngerti pola-pola utama — Singleton, Factory, Builder, Strategy, Observer, Decorator — lan endi saben siji pas yaiku tandha sing mbedakake pengembang berpengalaman lan topik sing kerep ing wawancara.

Samawa pentinge yaiku kaputusan kanggo terapake kanthi anggun (nglakoni masalah nyata) tinimbang maksa, utamane nalika fitur modern kaya lambda nyederhanakake akeh pola klasik.