Hằng số và final — giá trị khắc trên đá

TL;DR: final là cách Java nói "không đổi được" — nhưng nó áp lên biến (không gán lại), method (không override) và class (không extend) với ý nghĩa khác nhau. static final + UPPER_SNAKE_CASE là convention cho hằng số cấp class; với primitive/String literal, nó còn là compile-time constant được compiler inline. Bẫy lớn nhất của bài: final reference chỉ cố định địa chỉ, không cố định nội dung object — final List vẫn add() được như thường. Muốn bất biến thật sự phải dùng immutable object (List.of, String) hoặc tự viết immutable class: final class + final fields + không setter.

Bài 1 đến 7 tập trung vào giá trị thay đổi được. Bài này đi vào chiều ngược lại: khi nào bạn muốn một giá trị không được phép thay đổi — và keyword final thể hiện điều đó ở ba cấp độ khác nhau: biến, method, class. Còn cơ chế thứ ba của Java cho "tập giá trị cố định" — enum — có riêng bài kế tiếp.

1. Analogy khắc trên đá mô tả từ khóa final như thế nào?

Hãy nghĩ về hai kiểu "ghi":

• Viết trên giấy (biến thường) — dễ tẩy xoá, gán lại tuỳ ý.
• Khắc trên đá (final) — một khi đã khắc, không đổi được. Muốn "đổi" phải đục bỏ tảng đá cũ, lấy tảng mới.

2. Ba cơ chế không đổi được trong Java gồm những gì?

Hai cơ chế đầu là chủ đề của bài này; enum được mổ riêng ở bài 09.

3. Từ khóa final trên biến hoạt động ra sao?

3.1 Local variable

final int maxSize = 100;
maxSize = 200;  // COMPILE ERROR: cannot assign a value to final variable

Lưu ý convention: final local variable vẫn đặt tên camelCase như biến thường — chỉ static final (hằng số cấp class) mới dùng UPPER_SNAKE_CASE.

final local variable phải được gán đúng 1 lần trước khi dùng. Không nhất thiết gán ngay lúc khai báo:

final int threshold;
if ("strict".equals(mode)) {   // so sanh String bang equals, khong dung ==
    threshold = 10;
} else {
    threshold = 50;
}
// threshold da duoc gan 1 lan -- OK
System.out.println(threshold);

// threshold = 99;  // COMPILE ERROR

3.2 Field

public class Circle {
    final double radius;  // phai gan trong constructor hoac ngay tai day

    Circle(double r) {
        this.radius = r;  // gan 1 lan trong constructor
        // this.radius = r * 2;  // COMPILE ERROR: da gan roi
    }
}

3.3 Parameter

void process(final String input) {
    // input = "other";  // COMPILE ERROR
    System.out.println(input.toUpperCase());  // doc thoai mai
}

Khai báo parameter final ngăn vô tình gán lại bên trong method — hữu ích để đọc code rõ intent.

Thử ngẫmmột constructor trong dự án bạn gán field qua vài method phụ gọi bên trong nó, không gán trực tiếp — theo quy tắc "gán đúng 1 lần" của final, cách viết đó có compile được không?

4. Hằng số static final cấp class được định nghĩa và tối ưu như thế nào?

public class Config {
    public static final int    MAX_RETRIES    = 3;
    public static final double TAX_RATE       = 0.1;
    public static final String DEFAULT_LOCALE = "vi-VN";
}

// Dung o noi khac:
int retry = Config.MAX_RETRIES;  // khong can tao object Config

Quy tắc:

• Convention đặt tên: UPPER_SNAKE_CASE
• public static final với primitive hoặc String literal → compile-time constant — compiler inline giá trị vào chỗ dùng, không cần truy cập field lúc runtime.

// ANTI-PATTERN -- khong lam the nay
interface AppConstants {
    int MAX_RETRIES = 3;  // ngam la public static final
    String LOCALE = "vi-VN";
}
class MyService implements AppConstants { ... }  // BAD!

// DUNG: utility class voi constructor private
public final class AppConstants {
    private AppConstants() {}  // ngan instantiate
    public static final int MAX_RETRIES = 3;
    public static final String LOCALE = "vi-VN";
}

Thử ngẫmbạn thấy một interface trong dự án chỉ chứa toàn hằng số, không method nào — bạn để nguyên vì "chạy tốt mà", hay đề nghị refactor sang utility class? Vì sao?

5. Từ khóa final trên class và method có tác dụng gì?

5.1 final class — không thể extends

public final class Ssn {  // Social Security Number
    private final String value;
    Ssn(String value) { this.value = value; }
    // khong ai co the extends Ssn va override logic validation
}

// class MaliciousSsn extends Ssn { ... }  // COMPILE ERROR

Java standard library dùng nhiều final class: String, Integer, Double, LocalDate, UUID... Lợi ích:

• Security: ngăn ai ghi đè method để bypass logic quan trọng
• Performance: JIT compiler biết không có subclass → có thể inline method call
• Design: truyền đạt "class này là final, không được mở rộng"

5.2 final method — không thể override

public class Payment {
    public final void deduct(double amount) {
        // logic kieu toan quan trong, khong duoc phep override
        validate(amount);
        doDeduct(amount);
        log(amount);
    }

    protected void doDeduct(double amount) { /* subclass co the customize */ }
}

final method cho phép subclass kế thừa nhưng không thể thay đổi method đó. Hữu ích trong template method pattern: skeleton của thuật toán là final, các bước cụ thể thì protected có thể override.

6. Tại sao final reference không đồng nghĩa với immutable object?

Đây là điểm quan trọng nhất của bài:

final List<String> list = new ArrayList<>();

// list = new ArrayList<>();  // COMPILE ERROR: reference khong doi duoc

list.add("hello");  // OK! -- reference co dinh, nhung object thi van sua duoc
list.add("world");  // OK!
list.clear();       // OK!

final chỉ cố định địa chỉ (reference), không cố định nội dung object mà reference trỏ tới.

// Immutable object thuc su: List.of(), String, LocalDate
final List<String> immutableList = List.of("a", "b", "c");
// immutableList.add("d");  // UnsupportedOperationException -- object immutable
// immutableList = new ArrayList<>();  // COMPILE ERROR -- final reference

// final + mutable object: reference co dinh nhung noi dung doi duoc
final StringBuilder sb = new StringBuilder("hi");
sb.append("!");   // OK -- object van sua duoc
// sb = new StringBuilder();  // COMPILE ERROR -- reference co dinh

Thử ngẫmmột field final List<String> tags trong entity của bạn — đồng nghiệp giả định nó bất biến và truyền thẳng ra ngoài class, nhưng thực ra có bất biến không? Rủi ro cụ thể là gì?

7. Mẫu hình thiết kế Immutable Class hoàn chỉnh như thế nào?

Kết hợp final class + final fields + không có setter → class hoàn toàn immutable:

public final class Money {
    private final long amountCents;  // tien tinh bang xu, tranh float
    private final String currency;   // "VND", "USD"

    public Money(long amountCents, String currency) {
        if (amountCents < 0) throw new IllegalArgumentException("amount < 0");
        this.amountCents = amountCents;
        this.currency    = currency;
    }

    public long getAmountCents() { return amountCents; }
    public String getCurrency()  { return currency; }

    // "Thay doi" tao object moi, khong sua object hien tai
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) throw new IllegalArgumentException("Currency mismatch");
        return new Money(this.amountCents + other.amountCents, this.currency);
    }

    @Override
    public String toString() {
        return amountCents + " " + currency;
    }
}

// Su dung
Money a = new Money(100_000, "VND");
Money b = new Money(50_000, "VND");
Money total = a.add(b);      // tao Money moi 150_000 VND
System.out.println(total);   // 150000 VND
System.out.println(a);       // 100000 VND -- a khong doi

Immutable class có nhiều lợi ích: thread-safe tự nhiên, dễ reasoning, an toàn làm HashMap key.

8. Bảng tổng hợp tác dụng của final trên từng vị trí khai báo là gì?

9. Các bẫy pitfall thường gặp với từ khóa final là gì?

❌ final reference = immutable object: final List<String> list — list không thể trỏ sang list khác, nhưng list.add(...) vẫn OK.

❌ Constant Interface anti-pattern: interface chứa hằng số và class implements nó — hằng số lộ ra API public. Dùng utility class final class với constructor private thay thế.

❌ UPPER_SNAKE_CASE cho final local variable: convention này chỉ dành cho static final cấp class. final int MAX_SIZE = 100; trong body method gây hiểu nhầm là hằng số dùng chung — đặt final int maxSize như biến thường.

❌ Quên private AppConstants() {}: utility class hằng số nên có constructor private để tránh bị khởi tạo không cần thiết.

10. Tài liệu Deep Dive Oracle quy định gì về từ khóa final?

11. Điểm cốt lõi cần nhớ về final và hằng số là gì?

• final trên biến: Chặn việc gán lại giá trị; với reference, chỉ cố định con trỏ chứ không cấm sửa đổi trạng thái đối tượng.
• static final hằng số: Dùng chuẩn UPPER_SNAKE_CASE, đặt trong utility class có constructor private thay vì Constant Interface.
• final trên method & class: Method cấm override để khóa khung thuật toán, class cấm extends để bảo vệ tính bất biến và an toàn.
• Compile-time constant: Các hằng số nguyên thủy hoặc chuỗi literal được compiler inline trực tiếp tại nơi gọi.

12. Tự kiểm tra kiến thức về hằng số và final như thế nào?

Bài tiếp theo: Enum — tập giá trị cố định, type-safe thay cho magic number