Apa saja pola desain yang umum di Java?

Question

Accepted Answer

**Pola desain** adalah solusi yang dapat digunakan kembali untuk masalah desain perangkat lunak yang berulang. Sifat OOP Java dan ekosistemnya membuat beberapa pola sangat umum — mengetahuinya membantu Anda mengenali, mengkomunikasikan, dan menerapkan struktur yang terbukti. Mereka terbagi menjadi kategori kreatif, struktural, dan perilaku.

## Singleton (kreatif) — satu instans bersama

```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) — merangkum pembuatan objek

```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) — membangun objek kompleks langkah demi langkah

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

## Strategy (perilaku) — algoritma yang dapat dipertukarkan

```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) — publikasi/langganan

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

## Decorator (struktural) — bungkus untuk menambah perilaku

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

## Di mana pola muncul di Java sendiri

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

## Peringatan terhadap penggunaan 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 ini penting

Pola desain menyediakan kosakata bersama dan solusi terbukti untuk masalah desain yang umum, yang berharga untuk komunikasi ("gunakan Strategy di sini"), mengenali struktur dalam kode yang ada, dan menghindari menciptakan ulang solusi yang cacat.

Mereka muncul di seluruh perpustakaan Java sendiri (dekorator I/O, metode pabrik, pembangun, acara berbasis pengamat), jadi memahaminya membantu Anda menggunakan dan memperluas perpustakaan standar secara efektif.

Mengetahui pola utama — Singleton, Factory, Builder, Strategy, Observer, Decorator — dan di mana masing-masing cocok adalah ciri khas pengembang berpengalaman dan topik wawancara yang sering.

Sama pentingnya adalah pertimbangan untuk menerapkannya secara tepat (menyelesaikan masalah nyata) daripada memaksanya, terutama karena fitur modern seperti lambda menyederhanakan banyak pola klasik.