Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

OOP & Thiết kếMid13 phút đọc

Lập trình hướng đối tượng: object bất biến, equals/hashCode và final

Ôn 10 thẻ
Trong bài này

Cụm bài Lập trình hướng đối tượng: 1. Class, object, access modifier · 2. Bất biến, equals/hashCode, final · 3. Kế thừa, đóng gói, đa hình · 4. Abstract class, interface · 5. UML, quan hệ giữa class · 6. Wrapper, BigDecimal, String

Object có sửa được sau khi tạo không, khi nào hai object “bằng nhau”, và final khoá cái gì? Đọc xong, bạn viết được class bất biến, override equals/hashCode đúng, và giải thích vì sao đổi một hằng số lại sinh bug ở service khác. Nên đọc phần 1 trước (class, constructor, static).

Sơ đồ tóm tắt:

flowchart TD
  I[Class bất biến] --> I1["private final, không setter"]
  I --> I2[Class final]
  I --> I3[Copy phòng thủ]
  I --> R["record: bất biến nông"]
  E[Override equals] -->|bắt buộc| H[Override hashCode]
  H --> HM["HashMap/HashSet chạy đúng"]
  FN[final] --> FR["Khoá tham chiếu, không object"]
  ST[static] --> SC["Thuộc class hay object"]
  SF["Hằng static final"] -.->|bẫy| IN["Bị chép vào nơi dùng"]

1. Class và object bất biến (immutable)

Ý chính: object bất biến chỉ tạo và đọc được, không sửa được sau khi tạo; thao tác “sửa” trả về object mới. Nhờ vậy nó dùng chung giữa các thread mà không cần khoá.

  1. Mọi field là private final.
  2. Không có setter hay method nào đổi trạng thái.
  3. Class là final (hoặc constructor private), để lớp con không thêm được trạng thái có thể sửa.
  4. Defensive copy (copy phòng thủ): field là object sửa được (List, Date, mảng) thì copy khi nhận vào và không trả thẳng tham chiếu ra ngoài.
public final class Customer {
    private final String name;
    private final List<String> tags;

    public Customer(String name, List<String> tags) {
        this.name = Objects.requireNonNull(name);
        this.tags = List.copyOf(tags);            // copy và không sửa được
    }

    public String name() { return name; }
    public List<String> tags() { return tags; }   // an toàn vì đã là list bất biến

    public Customer withName(String newName) {    // "sửa" = tạo object mới
        return new Customer(newName, tags);
    }
}

Lợi ích: thread-safe (nhiều thread dùng cùng lúc vẫn đúng) không cần khoá, làm key của HashMap an toàn vì hash không đổi, dễ suy luận và cache.

Java 16+ có record: một dòng là có class bất biến kèm constructor, accessor, equals, hashCode, toString. Validation đặt trong compact constructor (constructor rút gọn, không cần lặp lại tham số):

public record Money(BigDecimal amount, String currency) {
    public Money {                                // compact constructor để kiểm tra dữ liệu
        if (amount.signum() < 0) throw new IllegalArgumentException("amount < 0");
    }
}
Ví dụ Circle trong slide chưa bất biến hoàn toàn

Circle trong slide có private double radius và chỉ có getter. Không có setter là chưa đủ: muốn bất biến hoàn toàn thì thêm final cho field (để chính class cũng không gán lại) và cho class (để lớp con không thêm trạng thái hay method sửa đổi).

2. Các method của Object: toString, equals, hashCode

Ý chính: mọi class kế thừa java.lang.Object nên đều có ba method này. Bản mặc định gần như vô dụng với value object, và equals với hashCode luôn phải override cùng nhau.

Method Mặc định Nên override để
toString() Animal@1b6d3586 (tên class + hash hệ 16) log và debug dễ, nhưng không in dữ liệu nhạy cảm (mật khẩu, token, số thẻ)
equals() so địa chỉ, giống == so theo nội dung với value object (Money, Fraction, Email)
hashCode() hash theo identity khớp với equals: bằng nhau thì cùng hash

Hợp đồng của equals: phản xạ (x.equals(x)), đối xứng, bắc cầu, nhất quán (gọi nhiều lần cùng kết quả), và x.equals(null) == false. toString() được gọi tự động khi in object hoặc nối chuỗi.

JPA entity có vấn đề riêng (id chỉ có sau khi lưu, proxy của Hibernate), xem bài ORM và JPA.

3. final đầy đủ

Ý chính: final nghĩa là “không đổi được nữa”; cái gì bị khoá tuỳ chỗ đặt. Nó khoá tham chiếu, không khoá object được trỏ tới.

Đặt ở Ý nghĩa Ví dụ
Biến cục bộ, tham số Chỉ gán đúng một lần final int max = 10;
Field của instance Phải được gán đúng một lần, trước khi constructor kết thúc private final String id;
Field static Gán một lần khi khởi tạo class; static final là cách khai báo hằng static final int MAX_RETRY = 3;
Method Lớp con không override được public final String payslip()
Class Không ai kế thừa được final class String

final và static không đối lập mà là hai trục độc lập: static = “thuộc class hay object” (tiết kiệm bộ nhớ chỉ là hệ quả), final = “gán lại được không”. static final là tổ hợp hay gặp nhất: hằng của class.

Ba điểm về final hay bị hỏi: effectively final, Java Memory Model, tham số
  • Biến cục bộ dùng trong lambda hoặc anonymous class phải là final hoặc effectively final (không bị gán lại sau khi khởi tạo), dù không ghi chữ final.
  • Java Memory Model (bộ quy tắc về việc thread này thấy gì từ thread khác) đảm bảo cho field final: thread khác thấy object đã tạo xong thì cũng thấy giá trị đúng của các field final, miễn là this không bị lộ ra ngoài trong constructor. Đây là lý do object bất biến an toàn khi chia sẻ giữa các thread.
  • final trên tham số method chủ yếu để đọc code rõ hơn; nó không ảnh hưởng gì tới người gọi, vì Java luôn truyền tham trị.

Bài tập

Đề đã viết lại ngắn gọn. Code đã chạy thử trên JDK 21.

1. Class phân số Fraction

Yêu cầu: tử số và mẫu số là private; có constructor, method rút gọn (chia cho ƯCLN), method trả về dạng chuỗi "a/b", và bốn phép cộng, trừ, nhân, chia trả về phân số mới; viết main để thử.

Lời giải Bài 1: class Fraction bất biến
public final class Fraction {
    private final long numerator;
    private final long denominator;

    public Fraction(long numerator, long denominator) {
        if (denominator == 0) throw new ArithmeticException("Mẫu số phải khác 0");
        if (denominator < 0) {                 // chuẩn hoá: dấu luôn nằm ở tử số
            numerator = -numerator;
            denominator = -denominator;
        }
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public Fraction reduce() {
        long g = gcd(Math.abs(numerator), denominator);
        return g <= 1 ? this : new Fraction(numerator / g, denominator / g);
    }

    public Fraction add(Fraction o) {
        return new Fraction(numerator * o.denominator + o.numerator * denominator,
                            denominator * o.denominator).reduce();
    }

    public Fraction subtract(Fraction o) { return add(new Fraction(-o.numerator, o.denominator)); }

    public Fraction multiply(Fraction o) {
        return new Fraction(numerator * o.numerator, denominator * o.denominator).reduce();
    }

    public Fraction divide(Fraction o) {
        if (o.numerator == 0) throw new ArithmeticException("Không chia được cho phân số 0");
        return new Fraction(numerator * o.denominator, denominator * o.numerator).reduce();
    }

    private static long gcd(long a, long b) {
        while (b != 0) { long t = a % b; a = b; b = t; }
        return a;
    }

    @Override public String toString() {
        return denominator == 1 ? String.valueOf(numerator) : numerator + "/" + denominator;
    }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Fraction other)) return false;
        Fraction a = reduce(), b = other.reduce();
        return a.numerator == b.numerator && a.denominator == b.denominator;
    }

    @Override public int hashCode() {
        Fraction r = reduce();
        return Objects.hash(r.numerator, r.denominator);
    }

    public static void main(String[] args) {
        Fraction a = new Fraction(1, 2), b = new Fraction(3, 4);
        System.out.println(a.add(b));       // 5/4
        System.out.println(a.subtract(b));  // -1/4
        System.out.println(a.multiply(b));  // 3/8
        System.out.println(a.divide(b));    // 2/3
        System.out.println(new Fraction(6, -8).reduce());   // -3/4
        System.out.println(new Fraction(2, 4).equals(new Fraction(1, 2)));   // true
    }
}

Các quyết định thiết kế:

  • Bất biến: mọi phép toán trả về object mới, giống BigDecimal.
  • Không cho mẫu số bằng 0: invariant (điều luôn phải đúng) được giữ trong constructor.
  • Chuẩn hoá dấu: dấu luôn nằm ở tử số.
  • equals và hashCode so trên dạng đã rút gọn, để 2/4 bằng 1/2.
  • Tử và mẫu rất lớn thì phép nhân có thể tràn long; khi đó dùng Math.multiplyExact hoặc chuyển sang BigInteger.

Ghi nhớ

  • Kể được bốn bước viết một class bất biến, và vì sao record vẫn cần List.copyOf.
  • Giải thích được vì sao override equals mà quên hashCode làm HashSet.contains trả về false.
  • Phân biệt được == và equals, và biết khi nào == là đúng (kiểu nguyên thuỷ, enum).
  • Nói được final khoá gì ở từng vị trí, và vì sao final List vẫn thêm phần tử được.
  • Giải thích được vì sao đổi hằng static final trong thư viện mà service khác vẫn dùng giá trị cũ.

Câu hỏi phỏng vấn

Junior

Field final List<String> items có còn thêm phần tử được không?

Được. final chỉ cấm gán lại tham chiếu, còn object ArrayList bên dưới vẫn sửa được.

items = new ArrayList<>() mới là lỗi biên dịch. Muốn nội dung không đổi thì gán một list bất biến (List.copyOf, List.of) và không lộ list có thể sửa ra ngoài.

== và equals khác nhau thế nào?

== so giá trị với kiểu nguyên thuỷ và so identity (cùng một object không) với tham chiếu; equals so nội dung nếu class override nó.

  • Class override equals: String, Integer, record. Bản mặc định của Object cũng chỉ là ==.
  • So chuỗi phải dùng equals ("a" == new String("a") là false); enum so bằng == được vì mỗi hằng là duy nhất.
  • Viết "ACTIVE".equals(status) hoặc Objects.equals(a, b) để không bị NPE khi giá trị có thể là null.

Mid

Vì sao override equals thì phải override hashCode?

Vì hợp đồng yêu cầu hai object equals nhau phải cùng hash, và HashMap/HashSet tìm bucket theo hash trước khi gọi equals.

Hash khác nhau thì object nằm ở bucket khác, và contains/get trả về sai dù hai object “bằng nhau”.

Làm sao tạo một class bất biến? Vì sao object bất biến hữu ích?

Field private final, không setter, class final, copy phòng thủ field có thể sửa khi nhận vào và khi trả ra; hoặc dùng record (vẫn phải copy collection).

Lợi ích: thread-safe mà không cần khoá, làm key của map an toàn, dễ suy luận, cache được, chia sẻ thoải mái.

Record khác một class bất biến tự viết ở đâu? Record có bất biến hoàn toàn không?

Record tự sinh mọi thứ của một class bất biến, nhưng chỉ bất biến nông: component là List có thể sửa thì vẫn sửa được.

  • Record (Java 16) sinh field private final, constructor đầy đủ, accessor, equals/hashCode/toString theo mọi component; class ngầm là final, không khai báo thêm field instance được.
  • Validation và List.copyOf đặt trong compact constructor.
  • Không hợp làm JPA entity (cần constructor không tham số, proxy, field thay đổi được), nhưng rất hợp cho DTO, value object và key của map.

Senior

Bạn đổi giá trị một hằng public static final int trong thư viện dùng chung và deploy lại thư viện, nhưng service khác vẫn dùng giá trị cũ. Vì sao?

Vì đó là compile-time constant: javac đã chép thẳng giá trị vào bytecode của service, không còn tham chiếu tới field trong thư viện.

Thay jar thư viện mà không biên dịch lại service thì service vẫn mang giá trị cũ. Cách tránh: giá trị có thể đổi thì đừng để ở dạng hằng public; dùng method static int maxRetry(), đọc từ config, hoặc kiểu không phải hằng (Integer.valueOf(3)). Với hằng thật sự không bao giờ đổi (Math.PI, mã HTTP) thì inline là tốt.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
immutable /ɪˈmjuːtəbl/ bất biến “Immutable objects are inherently thread-safe.”
defensive copy /dɪˈfensɪv ˈkɑːpi/ bản sao phòng thủ “I make a defensive copy of the list in the constructor.”
contract /ˈkɑːntrækt/ hợp đồng (API) “Equal objects must have equal hash codes; that is part of the contract.”
value object /ˈvæljuː ˈɑːbdʒekt/ object so sánh theo giá trị “Money is a value object, so two instances with the same amount are equal.”
shallow immutability /ˈʃæloʊ ɪˌmjuːtəˈbɪləti/ bất biến nông “Records give shallow immutability, so I copy lists in the compact constructor.”
hash bucket /hæʃ ˈbʌkɪt/ ngăn chứa theo hash “HashMap picks the bucket by hashCode, then compares keys with equals.”
compile-time constant /kəmˈpaɪl taɪm ˈkɑːnstənt/ hằng được inline lúc biên dịch “Compile-time constants are inlined, so callers have to be recompiled.”
identity /aɪˈdentəti/ định danh của object “== compares identity, while equals compares state.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.