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 đá

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

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

3. final trên biến

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.

4. static final — hằng số cấp class

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";
}

5. final trên class và method

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. final reference KHÔNG phả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

7. Immutable class pattern

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: final trên từng target

9. Pitfall tổng hợp

❌ 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. 📚 Deep Dive Oracle

11. Tóm tắt

• final biến: không thể gán lại. final field gán 1 lần tại khai báo hoặc constructor. Local final vẫn đặt tên camelCase.
• final method: không thể override trong subclass — khoá behavior quan trọng nhưng vẫn cho extend class.
• final class: không thể extend. Ví dụ: String, Integer, LocalDate.
• final reference ≠ immutable object: reference cố định, nhưng nội dung object vẫn thay đổi nếu object mutable.
• static final hằng số cấp class: convention UPPER_SNAKE_CASE. Đặt trong utility class với constructor private, không dùng constant interface.
• Primitive/String static final gán ngay bằng literal → compile-time constant, được compiler inline.
• Immutable class pattern: final class + final fields + không setter — thread-safe tự nhiên, an toàn làm HashMap key.

12. Tự kiểm tra

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