Có những loại nested class nào trong Java?

Question

Accepted Answer

Một **nested class** là một class được định nghĩa bên trong một class khác. Java có bốn loại — **static nested**, **inner (non-static)**, **local**, và **anonymous** — mỗi loại có quyền truy cập khác nhau vào class bao bọc và các trường hợp sử dụng khác nhau.

## 1. Static nested class — độc lập với instance

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

static class Nested {            // static → không có reference tới một INSTANCE của Outer
        void show() {
            System.out.println(data);  // chỉ có thể truy cập các static member của Outer
        }
    }
}
Outer.Nested n = new Outer.Nested();   // tạo mà không cần một instance của Outer
```

Một static nested class hành xử như một top-level class nhưng được đặt trong namespace bên trong class ngoài. Nó **không** giữ reference tới một instance ngoài — dùng để nhóm các helper (ví dụ một `Builder`, `Node` trong một cấu trúc dữ liệu).

## 2. Inner (non-static) class — gắn với một instance

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

class Inner {                     // non-static → có reference ngầm tới Outer
        void show() {
            System.out.println(value); // có thể truy cập INSTANCE member của Outer (kể cả private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // cần một instance của Outer để tạo
```

Một inner class non-static giữ một reference ngầm tới instance bao bọc của nó, nên nó có thể truy cập các instance field của object ngoài. (Lưu ý: reference này có thể gây **memory leak** nếu instance inner sống lâu hơn instance outer.)

## 3. Local class — định nghĩa bên trong một method

```java
void process() {
    class Helper {                    // cục bộ trong method này
        void run() { ... }
    }
    new Helper().run();
}
```

Hiếm khi dùng; phạm vi giới hạn trong method.

## 4. Anonymous class — implementation dùng một lần, không tên

```java
// implement một interface/abstract class inline, dùng một lần
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

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

Một anonymous class là một implementation dùng một lần của một interface hoặc class, được định nghĩa và khởi tạo cùng lúc — trước đây phổ biến cho event handler và callback. Java hiện đại thường thay thế chúng bằng **lambda** khi target là một functional interface:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — sạch hơn nhiều
Runnable task = () -> System.out.println("running");
```

## Tại sao điều này quan trọng

Nested class là một công cụ hữu ích để **nhóm về mặt logic** những class chỉ được dùng trong một ngữ cảnh, tăng tính encapsulation và dễ đọc.

Hiểu các loại — đặc biệt là **sự phân biệt static-vs-inner** (static = độc lập, inner = giữ một reference tới instance bao bọc) — quan trọng cho cả thiết kế lẫn tránh lỗi: reference ngầm tới outer của inner class có thể gây memory leak, và chọn static khi bạn không cần instance ngoài là lựa chọn mặc định sạch hơn.

Anonymous class là cách kinh điển để cung cấp các implementation inline (event handler, comparator), và biết rằng chúng phần lớn đã được lambda thay thế cho các functional interface phản ánh sự thông thạo Java hiện đại.

Chúng xuất hiện khắp thư viện chuẩn (ví dụ `Map.Entry` là một nested interface, các builder là static nested class), khiến chúng trở thành kiến thức thực tiễn, thường gặp.