Apakah corak reka bentuk umum yang terdapat dalam Java?

Question

Accepted Answer

**Corak reka bentuk** adalah penyelesaian yang boleh digunakan semula untuk masalah reka bentuk perisian yang berulang. Sifat OOP Java dan ekosistemnya menjadikan beberapa corak sangat biasa — mengetahui mereka membantu anda mengenali, berkomunikasi, dan menggunakan struktur yang telah terbukti. Mereka terbahagi kepada kategori penciptaan, struktur, dan tingkah laku.

## Singleton (penciptaan) — 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 (penciptaan) — mengenkapsulasi penciptaan 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 (penciptaan) — membina 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 (tingkah laku) — algoritma yang boleh ditukar

```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 (tingkah laku) — terbit/langgan

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

## Decorator (struktur) — bungkus untuk menambah tingkah laku

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

## Tempat corak muncul dalam Java itu 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
```

## Amaran 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 ia penting

Corak reka bentuk menyediakan perbendaharaan bersama dan penyelesaian yang telah terbukti untuk masalah reka bentuk umum, yang bernilai untuk komunikasi ("gunakan Strategi di sini"), mengenali struktur dalam kod sedia ada, dan mengelakkan penemuan semula penyelesaian yang cacat.

Mereka terdapat di seluruh perpustakaan piawai Java (hiasan I/O, kaedah kilang, peminjam, acara berasaskan pemerhati), jadi memahami mereka membantu anda menggunakan dan memperluas perpustakaan piawai dengan berkesan.

Mengetahui corak utama — Singleton, Factory, Builder, Strategy, Observer, Decorator — dan di mana setiap corak sesuai adalah ciri khas pembangun berpengalaman dan topik temu duga yang kerap.

Sama pentingnya adalah kebijaksanaan untuk menggunakannya dengan sesuai (menyelesaikan masalah nyata) daripada memaksakan mereka, terutamanya kerana ciri-ciri moden seperti lambdas menyederhanakan banyak corak klasik.