nested class ใน Java มีกี่ชนิด อะไรบ้าง?

Question

Accepted Answer

**nested class** คือคลาสที่นิยามไว้ภายในอีกคลาสหนึ่ง Java มีอยู่สี่ชนิด ได้แก่ **static nested**, **inner (non-static)**, **local** และ **anonymous** แต่ละชนิดมีการเข้าถึงคลาสที่ล้อมรอบและกรณีการใช้งานที่ต่างกัน

## 1. static nested class — เป็นอิสระจากอินสแตนซ์

```java
public class Outer {
    private static int data = 10;

static class Nested {            // static → no reference to an Outer INSTANCE
        void show() {
            System.out.println(data);  // can access static members of Outer only
        }
    }
}
Outer.Nested n = new Outer.Nested();   // created without an Outer instance
```

`static` nested class ทำงานเหมือนคลาสระดับบนสุด (top-level) แต่ถูกจัดอยู่ใน namespace ภายในคลาสนอก มัน **ไม่** ถือ reference ไปยังอินสแตนซ์ของคลาสนอก ใช้สำหรับการจัดกลุ่มตัวช่วย (เช่น `Builder`, `Node` ในโครงสร้างข้อมูล)

## 2. inner (non-static) class — ผูกกับอินสแตนซ์

```java
public class Outer {
    private int value = 5;

class Inner {                     // non-static → has an implicit reference to Outer
        void show() {
            System.out.println(value); // can access Outer's INSTANCE members (even private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // needs an Outer instance to create
```

**inner** class ที่ไม่ใช่ static ถือ reference โดยปริยายไปยังอินสแตนซ์ที่ล้อมรอบ จึงเข้าถึง field แบบอินสแตนซ์ของอ็อบเจกต์นอกได้ (ข้อควรระวัง: reference นี้อาจทำให้เกิด **memory leak** ได้ถ้าอินสแตนซ์ inner มีอายุยืนกว่าอินสแตนซ์นอก)

## 3. local class — นิยามไว้ภายในเมธอด

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

ใช้น้อยมาก มีขอบเขตจำกัดอยู่ในเมธอด

## 4. anonymous class — การ implement แบบใช้ครั้งเดียว ไม่มีชื่อ

```java
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

Runnable task = new Runnable() {
    public void run() { System.out.println("running"); }
};
```

**anonymous** class คือการ implement interface หรือคลาสแบบใช้ครั้งเดียว ที่นิยามและสร้างอินสแตนซ์ในคราวเดียว ในอดีตนิยมใช้กับ event handler และ callback Java สมัยใหม่มักแทนที่สิ่งเหล่านี้ด้วย **lambda** เมื่อเป้าหมายเป็น functional interface:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## ทำไมจึงสำคัญ

nested class เป็นเครื่องมือที่มีประโยชน์ในการ **จัดกลุ่มเชิงตรรกะ** สำหรับคลาสที่ใช้ในบริบทเดียวเท่านั้น ช่วยเพิ่ม encapsulation และความอ่านง่าย

การเข้าใจชนิดต่าง ๆ โดยเฉพาะ **ความแตกต่างระหว่าง static กับ inner** (static = เป็นอิสระ, inner = ถือ reference ไปยังอินสแตนซ์ที่ล้อมรอบ) สำคัญทั้งต่อการออกแบบและการหลีกเลี่ยงบั๊ก: reference โดยปริยายไปยังคลาสนอกของ inner class อาจทำให้เกิด memory leak ได้ และการเลือก static เมื่อคุณไม่ต้องการอินสแตนซ์นอกเป็นค่าเริ่มต้นที่สะอาดกว่า

anonymous class เคยเป็นวิธีคลาสสิกในการให้การ implement แบบ inline (event handler, comparator) และการรู้ว่ามันถูกแทนที่ด้วย lambda เป็นส่วนใหญ่สำหรับ functional interface สะท้อนถึงความคล่องแคล่วกับ Java สมัยใหม่

สิ่งเหล่านี้ปรากฏอยู่ทั่วทั้งไลบรารีมาตรฐาน (เช่น `Map.Entry` เป็น nested interface, builder เป็น static nested class) ทำให้เป็นความรู้เชิงปฏิบัติที่พบเจอบ่อย