มีรูปแบบการออกแบบทั่วไปใดบ้างที่ปรากฏใน Java?

Question

Accepted Answer

**รูปแบบการออกแบบ** เป็นวิธีแก้ปัญหาที่นำมาใช้ซ้ำได้สำหรับปัญหาการออกแบบซอฟต์แวร์ที่เกิดขึ้นซ้ำ ลักษณะ OOP ของ Java และระบบนิเวศของมันทำให้รูปแบบหลายแบบเป็นเรื่องธรรมดาโดยเฉพาะ — การรู้จักพวกมันจะช่วยให้คุณจำได้ สื่อสาร และนำโครงสร้างที่ได้รับการพิสูจน์ไปใช้ พวกมันแบ่งออกเป็นหมวดหมู่การสร้าง โครงสร้าง และพฤติกรรม

## Singleton (การสร้าง) — อินสแตนซ์ที่ใช้ร่วมกันหนึ่งอันตัว

```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 (การสร้าง) — เข้ารหัสการสร้างวัตถุ

```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 (การสร้าง) — สร้างวัตถุที่ซับซ้อนทีละขั้นตอน

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

## Strategy (พฤติกรรม) — อัลกอริทึมที่สามารถแลกเปลี่ยนได้

```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 (พฤติกรรม) — เผยแพร่/สมัครสมาชิก

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

## Decorator (โครงสร้าง) — ห่อให้เพิ่มพฤติกรรม

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

## รูปแบบที่ปรากฏใน 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
```

## คำเตือนเกี่ยวกับการใช้งานมากเกินไป

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

## เหตุที่สิ่งนี้มีความสำคัญ

รูปแบบการออกแบบมีคำศัพท์ที่ใช้ร่วมกันและวิธีแก้ปัญหาที่ได้รับการพิสูจน์สำหรับปัญหาการออกแบบทั่วไป ซึ่งมีคุณค่าสำหรับการสื่อสาร ("ใช้ Strategy ที่นี่") การจำได้ว่าโครงสร้างใดอยู่ในโค้ดที่มีอยู่ และการหลีกเลี่ยงการประดิษฐ์วิธีแก้ปัญหาที่มีข้อบกพร่องขึ้นมาใหม่

พวกมันปรากฏตลอดไลบรารี Java เอง (I/O decorator, method factory, builder, event-based observer) ดังนั้นการเข้าใจพวกมันจะช่วยให้คุณใช้และขยายไลบรารีมาตรฐานได้อย่างมีประสิทธิภาพ

การรู้จักรูปแบบหลัก — Singleton, Factory, Builder, Strategy, Observer, Decorator — และสถานที่ที่แต่ละรูปแบบเหมาะสมนั้นเป็นลักษณะเฉพาะของนักพัฒนาที่มีประสบการณ์และเป็นหัวข้อที่ถูกถามบ่อยในการสัมภาษณ์

เท่าสำคัญกับสิ่งนี้คือการตัดสินใจที่ดีในการนำมาใช้อย่างเหมาะสม (แก้ปัญหาจริง) แทนที่จะบังคับใช้มัน โดยเฉพาะอย่างยิ่งเมื่อคุณลักษณะสมัยใหม่เช่น lambda ช่วยลดความซับซ้อนของรูปแบบดั้งเดิมหลายแบบ