Scope, shadowing và lifetime — biến sống ở đâu, đến khi nào

Bạn khai báo int x = 10 ở đầu method, rồi ở giữa có block { int x = 20; }. Compile được không? Nếu bạn từng viết C/C++, câu trả lời sẽ làm bạn bất ngờ. Còn khi parameter trùng tên field, truy cập field thế nào? Và nếu lambda bên trong đọc x, phiên bản nào được lấy?

Những câu hỏi trên đều liên quan đến scope — phạm vi mà một cái tên biến có ý nghĩa, và lifetime — khoảng thời gian biến tồn tại trên memory. Hiểu hai khái niệm này giúp bạn tránh bug tinh vi: biến bị shadow, closure bắt sai giá trị, NPE do dùng biến ngoài scope.

1. Analogy — phòng trong nhà

Căn nhà có nhiều phòng. Bạn dán nhãn "remote TV" trên kệ phòng khách — chỉ phòng khách hiểu nhãn này, phòng bếp không biết. Phòng ngủ (phòng ngang hàng, không lồng trong phòng khách) cũng dán nhãn "remote TV" trên remote điều hòa — không sao, hai phòng độc lập, không ai nhầm với ai. Nhưng nhà còn có bảng nhãn chung treo ở sảnh (field của class) — khi một phòng dán nhãn trùng tên với nhãn ở sảnh, người đứng trong phòng đó sẽ hiểu nhãn theo nghĩa của phòng. Nhãn ở sảnh bị che (shadow).

2. Block scope — phạm vi đi theo { }

Scope trong Java bám theo block (cặp { }):

public static void demo() {
    int a = 1;          // scope: toan method

    if (true) {
        int b = 2;      // scope: trong block if
        System.out.println(a + b);   // OK — thay ca a (outer) va b (inner)
    }

    // System.out.println(b);  // COMPILE ERROR — b khong con thay
    System.out.println(a);       // OK
}

Scope lồng nhau theo cây — biến ngoài thấy trong; biến trong không lan ra ngoài.

2.1 Scope của parameter và for-counter

Parameter có scope = toàn body method:

public static int doubled(int x) {
    return x * 2;   // x thay trong het body
}

Biến khai báo trong for (int i = 0; ...) có scope = chỉ trong for:

for (int i = 0; i < 10; i++) { ... }
// System.out.println(i);   // COMPILE ERROR

Biến khai báo với for-each (for (int x : arr)), try-with-resources, catch (Exception e) — cùng nguyên tắc, scope hẹp trong block tương ứng.

3. Shadowing — luật của Java nghiêm hơn C/C++

Java cấm khai báo local mới trùng tên khi biến local cũ còn trong scope — kể cả trong block con (JLS §6.4):

int x = 1;
int x = 2;   // COMPILE ERROR — variable x is already defined

int y = 1;
if (condition) {
    int y = 2;   // COMPILE ERROR — scope cua y ngoai phu ca block nay
}

Compiler báo variable y is already defined in method .... Đây là điểm khác biệt với C/C++ — nơi block con được phép khai báo biến trùng tên che biến ngoài:

// C/C++ — hop le, nhung de gay bug kho thay
int x = 1;
if (condition) {
    int x = 2;   // shadow x ngoai — compiler im lang
}

Vì sao Java cấm? Local che local là nguồn bug kinh điển trong C/C++: người đọc tưởng code đang sửa biến ngoài, thực chất chỉ đụng biến trong — và compiler không nói gì. Java chọn fail sớm tại compile time để loại hẳn lớp bug này.

Chỉ có hai trường hợp được dùng lại tên một cách hợp lệ:

(1) Hai block ngang hàng — scope của biến cũ đã đóng trước khi khai báo lại:

{
    int temp = 1;
}   // scope cua temp ket thuc tai day
{
    int temp = 2;   // OK — hai scope khong giao nhau
}

Hai biến temp hoàn toàn độc lập. Đây không phải shadowing — chỉ là tái sử dụng tên sau khi tên cũ hết hiệu lực.

(2) Local / parameter che field — đây mới là shadowing đúng nghĩa trong Java (xem 3.1).

Parameter cũng theo luật cấm trên. Scope của parameter phủ toàn bộ method body, nên không khai báo lại được ở bất kỳ đâu trong body:

public static void f(int x) {
    for (int x = 0; x < 10; x++) { ... }   // COMPILE ERROR — trung ten parameter
    {
        int x = 99;   // COMPILE ERROR — scope cua parameter phu ca block con
    }
}

3.1 Shadow field bằng local/parameter — dạng shadowing bạn gặp hằng ngày

Khi học OOP, bạn sẽ gặp pattern này liên tục:

class Person {
    private String name;

    public void setName(String name) {   // parameter 'name' shadow field 'name'
        this.name = name;                 // dung this de tro field
    }
}

name trong body của setName ám chỉ parameter, không phải field. Muốn truy cập field bị shadow → dùng this.. Đây là pattern tiêu chuẩn, không phải anti-pattern.

class Counter {
    private int count = 0;
    public void inc() {
        int count = this.count;   // shadow
        count++;                   // chi sua local
        // quen gan lai this.count = count
    }
}

4. Lifetime — biến sống bao lâu

Scope quyết định ở đâu dùng được tên biến. Lifetime quyết định bao lâu ô nhớ tồn tại.

Ví dụ:

class Order {
    static int totalOrdersCreated = 0;   // static field
    private int id;                       // instance field

    public Order(int id) {
        this.id = id;
        totalOrdersCreated++;
    }

    public void print() {
        String prefix = "Order-";        // local — song trong print()
        System.out.println(prefix + id);
    }
}

• totalOrdersCreated sống từ khi class Order được JVM load đến khi JVM tắt.
• id sống cùng mỗi object Order — object bị GC thì id biến mất.
• prefix sống trong một lần gọi print() — method return → frame pop → prefix biến mất.

5. Effectively final — điều kiện để biến dùng trong lambda / inner class

Lambda và anonymous inner class được phép đọc biến local của method bao ngoài, nhưng biến đó phải effectively final — khai báo rồi không bị gán lại trước/sau lambda.

public static void demo() {
    int x = 10;
    Runnable r = () -> System.out.println(x);   // OK — x effectively final

    int y = 20;
    y = 21;
    Runnable r2 = () -> System.out.println(y);   // COMPILE ERROR — y khong effectively final
}

Lý do: lambda có thể chạy sau khi method bao đã return (vd submit vào thread pool). JVM bắt giá trị của biến tại lúc tạo lambda — nếu biến tiếp tục bị thay đổi, giá trị bắt sẽ lệch với giá trị hiện tại. Java chọn giải pháp an toàn: cấm.

5.1 Workaround khi cần "biến thay đổi" trong lambda

// Cach 1: array 1 phan tu (hack co dien)
int[] counter = {0};
list.forEach(x -> counter[0]++);

// Cach 2: AtomicInteger (dung cho multi-thread)
AtomicInteger c = new AtomicInteger(0);
list.forEach(x -> c.incrementAndGet());

// Cach 3: reduce thay vi side-effect (functional style)
long count = list.stream().filter(x -> x > 0).count();

Trong đa số trường hợp, cách 3 — chuyển side-effect thành reduce/stream — là sạch nhất và đúng tinh thần functional.

6. Scope của try-with-resources và catch

try (BufferedReader r = new BufferedReader(new FileReader("a.txt"))) {
    // r thay trong day
} catch (IOException e) {
    // e thay trong day
    System.out.println(e.getMessage());
}
// r, e ra ngoai scope — khong dung duoc

Đây là lý do bài "Variables" Module 2 nhấn mạnh try-with-resources — nó tự đóng r và làm r ra khỏi scope luôn, tránh reuse biến đã đóng.

7. Pitfall tổng hợp

❌ Nhầm 1: Cố dùng biến của for sau khi vòng kết thúc.

for (int i = 0; i < 10; i++) { ... }
System.out.println(i);   // COMPILE ERROR

✅ Khai báo i trước for nếu cần dùng sau — nhưng thường thiết kế lại sạch hơn.

❌ Nhầm 2: Shadow field bằng local mà quên this..

void setAge(int age) { age = age; }   // tu gan local cho chinh no

✅ this.age = age;. Hoặc đổi tên parameter (newAge) để rõ ý.

❌ Nhầm 3: Cố gán lại biến dùng trong lambda.

int x = 0;
list.forEach(item -> x++);   // COMPILE ERROR

✅ Dùng reduce/count, hoặc AtomicInteger nếu thực sự cần mutable.

❌ Nhầm 4: Khai báo biến trong vòng loop nhưng tưởng giữ giá trị giữa các vòng.

for (int i = 0; i < 5; i++) {
    int sum = 0;    // reset moi vong — co the khong phai y do
    sum += i;
}

✅ Nếu muốn tích luỹ, khai báo sum ngoài loop.

❌ Nhầm 5: Static field bị "rò rỉ" memory vì tham chiếu object không release.

class Registry {
    static List<User> all = new ArrayList<>();   // giu moi User song mai
}

✅ Static collection cần chiến lược xoá (weak reference, TTL, cleanup). Sẽ đào ở module Memory & GC.

8. 📚 Deep Dive Oracle

9. Tóm tắt

• Scope của biến local là block ({ }) chứa nó. Ra khỏi block, tên biến không còn ý nghĩa.
• Java cấm khai báo local mới trùng tên khi local cũ (hoặc parameter) còn trong scope — kể cả trong block con. Đây là điểm khác C/C++. Chỉ được dùng lại tên ở block ngang hàng, sau khi scope cũ đã đóng.
• Shadowing trong Java nghĩa là local/parameter che field cùng tên (và nested class che biến bao ngoài) — không phải local che local. Muốn truy cập field bị che, dùng this..
• Lifetime: biến local sống theo stack frame; instance field sống theo object; static field sống từ khi class được load đến khi JVM tắt.
• Lambda / inner class capture biến local yêu cầu biến đó effectively final (không bị gán lại).
• Muốn mutable trong lambda: reduce/stream (sạch), hoặc AtomicInteger / array 1 phần tử (hack).
• try-with-resources giới hạn scope của resource trong try block — không reuse được ngoài.

10. Tự kiểm tra

int x = 1;
if (true) {
    int x = 2;
    System.out.println(x);
}
System.out.println(x);

public static void f(int x) {
    int x = 10;
    System.out.println(x);
}

public static void f(int x) {
    {
        int x = 10;   // van COMPILE ERROR — scope parameter phu ca block con
    }
}

class Person {
    private String name;
    public void setName(String name) {
        name = name;
    }
}

this.name = name;

int counter = 0;
Runnable r = () -> counter++;

class Foo {
    static int counter = 0;   // scope: moi noi co the truy qua Foo.counter
                              // lifetime: tu khi class load den khi JVM tat
    private int id;           // scope: moi instance method cua Foo
                              // lifetime: bang lifetime cua object instance

    void hello() {
        int n = 10;           // scope: trong body hello()
                              // lifetime: tu khi frame push den khi hello() return
    }
}

Bài tiếp theo: Mini-challenge: thư viện NumberUtils với method tĩnh