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á.
- Mọi field là
private final. - Không có setter hay method nào đổi trạng thái.
- Class là
final(hoặc constructor private), để lớp con không thêm được trạng thái có thể sửa. - 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à
finalhoặ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 fieldfinal, miễn làthiskhô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. finaltrê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ố.
equalsvàhashCodeso trên dạng đã rút gọn, để2/4bằng1/2.- Tử và mẫu rất lớn thì phép nhân có thể tràn
long; khi đó dùngMath.multiplyExacthoặc chuyển sangBigInteger.
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
equalsmà quênhashCodelàmHashSet.containstrả 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
finalkhoá gì ở từng vị trí, và vì saofinal Listvẫn thêm phần tử được. - Giải thích được vì sao đổi hằng
static finaltrong 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ủaObjectcũ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ặcObjects.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/toStringtheo 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.