Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Tạo và huỷ object đúng cách: static factory, builder, singleton và những cách phá singleton
1Static factory thay constructor
Method static trả về instance: có tên, được trả object có sẵn, được trả lớp con ẩn. JDK dùng khắp nơi: List.of, Integer.valueOf, Duration.ofSeconds.
public static Money of(BigDecimal a, String cur) {
if (a.signum() == 0 && cur.equals("VND"))
return ZERO_VND; // object có sẵn
return new Money(a, cur);
}
public static Money vnd(long a) { ... }
2Builder cho nhiều tham số tuỳ chọn
Từ khoảng bốn tham số, nhiều cái tuỳ chọn: tham số bắt buộc vào lúc tạo builder, tuỳ chọn qua method có tên, kiểm tra trong build(), ra object bất biến.
Cách
Vấn đề
Telescoping constructor
2, 1 không ai đọc ra là gì
JavaBeans + setter
Object dở dang, không bất biến
Builder
Rõ tên, kiểm tra tập trung
3Viết singleton
Singleton là một instance trong một phạm vi. Trong Spring, dùng bean; ngoài container, chọn theo nhu cầu lazy và mức phòng thủ.
flowchart TD
Q{"Chỉ một instance"} -->|"Có Spring"| B["Bean scope singleton"]
Q -->|"Không Spring, cần lazy"| H["Holder idiom, không lock"]
Q -->|"Chống reflection, serialization"| E["Enum một hằng"]
Q -->|"Đơn giản nhất"| F["public static final INSTANCE"]
4Bốn cách phá singleton
"Constructor private + field static" chỉ chặn new từ bên ngoài. Enum chống được ba cách đầu vì chính JVM từ chối.
Cách phá
Cách chống
Reflection
Cờ trong constructor; tuyệt đối thì enum
Serialization
readResolve() trả INSTANCE
Clone
Đừng implement Cloneable
Nhiều ClassLoader
Đặt ở loader cha dùng chung
5Object thừa, rò bộ nhớ, dọn dẹp
Tạo object rẻ, chỉ lo ở hot path. Quên bỏ tham chiếu mới là leak thật; tài nguyên ngoài heap đóng bằng try-with-resources.
Deprecated để xoá; dùng try-with-resources, Cleaner.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Đánh dấu utility class abstract: vẫn kế thừa được.
Tin cờ trong constructor chống reflection tuyệt đối.
Tự viết object pool cho object nhẹ.
Constructor là cách tạo object đầu tiên ai cũng học, nhưng code backend thật dùng nhiều thứ khác: List.of, Instant.now(), builder của DTO, bean singleton. Bài này là bộ quy tắc mình dùng khi thiết kế cách tạo và huỷ object, kèm thí nghiệm chứng minh vì sao singleton “chuẩn” vẫn bị phá. Nên đọc trước class, constructor và static và object bất biến.
Sơ đồ tóm tắt:
flowchart TD
Q{"Tạo object thế nào?"} -->|"vài tham số, ý nghĩa rõ"| C["Constructor"]
Q -->|"cần tên, cache, lớp con ẩn"| SF["Static factory: of/from/valueOf"]
Q -->|"nhiều tham số tuỳ chọn"| B["Builder + kiểm tra trong build()"]
Q -->|"chỉ một instance"| S{"Có Spring?"}
S -->|có| BEAN["Bean scope singleton"]
S -->|không| EN["Enum một hằng / holder idiom"]
Q -->|"chỉ có method static"| U["Utility class: constructor private"]
1. Static factory method thay cho constructor
Ý chính: một method static trả về instance của class. So với constructor, nó có tên, không bắt buộc tạo object mới, và được trả về bất kỳ lớp con nào. JDK dùng khắp nơi: List.of, Integer.valueOf, Optional.empty, EnumSet.noneOf, Duration.ofSeconds.
public final class Money { private static final Money ZERO_VND = new Money(BigDecimal.ZERO, "VND"); private final BigDecimal amount; private final String currency; private Money(BigDecimal amount, String currency) { this.amount = amount; this.currency = currency; } public static Money of(BigDecimal amount, String currency) { // tên nói rõ ý định if (amount.signum() == 0 && currency.equals("VND")) return ZERO_VND; // trả object có sẵn return new Money(amount, currency); } public static Money vnd(long amount) { return of(BigDecimal.valueOf(amount), "VND"); } public static Money parse(String text) { // "150000 VND" String[] parts = text.trim().split("\\s+"); return of(new BigDecimal(parts[0]), parts[1]); }}
Bốn lợi thế:
Có tên: Money.vnd(150_000) và Money.parse("150000 VND") đọc là hiểu; hai constructor cùng nhận một String thì không thể khai báo cả hai.
Không bắt buộc tạo mới: Integer.valueOf(100) trả object cache sẵn (-128..127), Boolean.valueOf chỉ có hai object. Class bất biến hưởng lợi nhiều nhất.
Trả lớp con ẩn: EnumSet.noneOf trả RegularEnumSet (≤ 64 hằng, một long) hoặc JumboEnumSet; List.of trả các class nội bộ khác nhau theo số phần tử. Người gọi chỉ biết interface, JDK đổi cài đặt mà không ai phải sửa code.
Lớp trả về có thể chưa tồn tại lúc viết API: DriverManager.getConnection trả Connection của driver được nạp lúc chạy (ý tưởng service provider).
Quy ước tên hay gặp: from (chuyển kiểu, một tham số), of (gom nhiều tham số), valueOf, getInstance/instance (có thể trả object dùng chung), create/newInstance (luôn mới), getXxx/newXxx khi method nằm ở class khác (Files.newBufferedReader).
2. Builder cho object nhiều tham số tuỳ chọn
Ý chính: khi có từ khoảng bốn tham số trở lên, nhiều cái tuỳ chọn hoặc dễ nhầm thứ tự, dùng builder: tham số bắt buộc vào lúc tạo builder, tham số tuỳ chọn qua method có tên, kiểm tra mọi ràng buộc trong build(), rồi tạo object bất biến.
Hai cách cũ đều có vấn đề:
Telescoping constructor (chuỗi constructor thêm dần tham số): new FlightSearch("HAN", "SGN", d, null, 2, 1, BUSINESS) không ai đọc ra 2 và 1 là gì; đổi chỗ hai int vẫn biên dịch được.
JavaBeans (constructor rỗng + setter): object tồn tại ở trạng thái dở dang giữa các lần gọi setter, không bất biến được, và ràng buộc giữa các field không có chỗ để kiểm tra.
FlightSearch search = FlightSearch.builder("HAN", "DAD", LocalDate.of(2026, 12, 20)) // bắt buộc .returnOn(LocalDate.of(2026, 12, 24)) // tuỳ chọn, có tên .adults(2).children(1) .cabin(Cabin.BUSINESS) .airline("VN").airline("VJ") .build(); // kiểm tra ràng buộc, rồi tạo object bất biến
Builder thường là static nested class của chính class đó (lý do ở nested class). Lombok @Builder sinh phần lặp, nhưng nhớ: nó không tự kiểm tra ràng buộc và không phân biệt tham số bắt buộc; ràng buộc vẫn phải viết tay (trong constructor hoặc method build() tuỳ biến).
3. Utility class: chặn việc tạo instance
Ý chính: class chỉ chứa method static (kiểu Collections, Objects) không nên tạo được instance. Cách đúng: constructor private ném AssertionError; đánh dấu abstract là sai vì vẫn kế thừa được và gợi ý sai rằng class được thiết kế để kế thừa.
public final class Slugs { private Slugs() { throw new AssertionError("utility class"); } // chặn cả reflection trong chính class public static String of(String title) { return title.toLowerCase(Locale.ROOT).trim().replaceAll("[^a-z0-9]+", "-"); }}
Trong backend, cân nhắc trước khi tạo utility class: logic có trạng thái hoặc cần mock trong test (gọi API, đọc giờ hệ thống) nên là bean được inject, không phải static. Clock inject được tốt hơn LocalDate.now() rải khắp code (xem ngày giờ trong backend).
4. Năm cách viết singleton
Ý chính: singleton là class chỉ có một instance trong một phạm vi. Trong ứng dụng Spring, phạm vi đó là container và cách đúng là bean scope singleton. Ngoài container, chọn giữa field static final (eager), holder idiom (lazy, không lock) và enum một hằng (chống reflection và serialization).
Cách
Lazy?
Thread-safe?
Chống reflection/serialization?
Ghi chú
public static final INSTANCE
không
có (khởi tạo class)
không
đơn giản nhất
private static final + getInstance()
không
có
không
đổi được cách tạo mà không đổi API
Holder idiom
có
có, không lock
không
dựa trên khởi tạo class lười
Double-checked locking + volatile
có
có nếu đủ volatile
không
dài, dễ viết sai; hiếm khi cần
Enum một hằng
không
có
có
không kế thừa class khác được
Holder idiom: class lồng Holder chỉ được khởi tạo khi get() được gọi lần đầu, và JVM đảm bảo khởi tạo class chạy đúng một lần dưới lock (xem vòng đời class).
public final class Lazy { private Lazy() { System.out.println(" Lazy() chạy"); } private static final class Holder { static final Lazy INSTANCE = new Lazy(); } public static Lazy get() { return Holder.INSTANCE; } public static void hello() { System.out.println(" hello, chưa tạo instance"); }}
holder idiom: hello, chưa tạo instance ← gọi method static khác không tạo instance Lazy() chạy ← lần get() đầu tiên ← get() lần hai: không in gì
Ý chính: “constructor private + một field static” chỉ chặn được new từ bên ngoài. Reflection gọi được constructor private, deserialize tạo object mới không qua constructor, clone() chép object, và hai ClassLoader cho hai bản class với hai field static.
Thí nghiệm trên JDK 21 với Registry (singleton viết tay, cố tình implements Serializable, Cloneable), SafeRegistry (có phòng thủ) và một enum:
reflection : false ← c.setAccessible(true); c.newInstance() tạo instance thứ haiserialization : false ← readObject tạo object mớiclone : false ← super.clone() chép objectsafe reflect : SafeRegistry đã có instancesafe serialize: trueenum reflect : Cannot reflectively create enum objectsenum serialize: true
Cách phá
Vì sao được
Cách chống
Reflection
setAccessible(true) gọi constructor private
constructor kiểm tra cờ và ném exception; tuyệt đối thì dùng enum
Serialization
deserialize tạo object bằng cơ chế riêng, không gọi constructor của class
readResolve() trả INSTANCE; field instance khai báo transient; hoặc dùng enum
class được định danh bằng tên + loader, mỗi loader có field static riêng
đặt class singleton ở loader cha dùng chung; hoặc chấp nhận “một mỗi loader”
6. Tránh object thừa và reference lỗi thời
Ý chính: tạo object trong Java rẻ (TLAB, GC thế hệ), nên chỉ lo ở hot path và với object đắt. Ngược lại, quên bỏ tham chiếu tới object không cần là memory leak thật.
Những chỗ đáng sửa:
Boxing trong vòng lặp: cộng dồn 200 triệu số bằng Long sum mất 302 ms, bằng long sum mất 54 ms (JDK 21), kèm 39 lần GC chỉ để dọn Long. Dùng primitive và primitive stream (mapToLong).
Object đắt dựng lại mỗi lần: Pattern.compile (hoặc String.matches, gọi compile mỗi lần) trong method được gọi liên tục; ObjectMapper tạo mới mỗi request. Dựng một lần, giữ trong field static final hoặc bean.
new String("x"), new Boolean(true): vô nghĩa với kiểu bất biến; dùng literal và valueOf.
Đừng làm: object pool tự viết cho object nhẹ (pool làm GC khó hơn và thêm lỗi đồng bộ). Pool chỉ đáng với thứ thật sự đắt hoặc có giới hạn bên ngoài: connection database (HikariCP), thread.
Reference lỗi thời: stack tự viết làm rò bộ nhớ
Khi class tự quản lý bộ nhớ của nó (mảng nội bộ, cache, danh sách listener), GC không biết phần tử nào “đã bỏ”:
public class BoundedStack<E> { private Object[] items = new Object[16]; private int size; public void push(E e) { /* grow nếu cần */ items[size++] = e; } @SuppressWarnings("unchecked") public E pop() { if (size == 0) throw new NoSuchElementException(); E e = (E) items[--size]; items[size] = null; // không có dòng này: mảng vẫn giữ object đã pop, GC không dọn được return e; }}
Không có dòng gán null, stack từng có một triệu phần tử rồi pop hết vẫn giữ một triệu object sống. ArrayList.remove và ArrayDeque.poll của JDK đều gán null vì lý do này. Quy tắc: chỉ gán null khi class tự quản lý vùng nhớ; biến cục bộ thì để nó ra khỏi phạm vi là đủ. Ba nguồn leak cùng họ: cache không giới hạn, listener/callback đăng ký không gỡ, ThreadLocal trên pool thread. Cách tìm leak bằng heap dump ở garbage collector và OOM.
7. Huỷ và chép object: try-with-resources, Cleaner, copy constructor
Ý chính: tài nguyên ngoài heap (file, socket, connection, lock) phải được đóng chủ động bằng try-with-resources. finalize() deprecated để xoá (JDK 18); Cleaner chỉ là lưới an toàn khi người dùng quên đóng. Để chép object, dùng copy constructor hoặc copy factory thay vì clone().
finalize() không biết khi nào chạy (có thể không bao giờ), chạy trên thread lạ, làm object sống thêm một chu kỳ GC và từng là lỗ hổng bảo mật (finalizer attack). Đừng viết mới.
Cleaner (JDK 9): đăng ký một hành động dọn chạy khi object không còn reachable. Dùng làm phương án dự phòng trong close() của class bọc tài nguyên native, không thay cho close().
try-with-resources với AutoCloseable: đóng theo thứ tự ngược, giữ suppressed exception (chi tiết ở exception trong Java).
Bài tập
Bài 1: builder cho tìm kiếm chuyến bay
Đề: viết FlightSearch bất biến với builder: bắt buộc from, to, departDate; tuỳ chọn returnDate, adults (mặc định 1), children (mặc định 0), cabin (mặc định ECONOMY), danh sách hãng bay. build() phải từ chối: from == to, ngày về trước ngày đi, adults < 1, tổng hành khách ngoài 1..9, quá 2 trẻ em mỗi người lớn, và báo tất cả lỗi một lần.
Lời giải Bài 1
import java.time.LocalDate;import java.util.*;public final class FlightSearch { public enum Cabin { ECONOMY, BUSINESS } private final String from, to; private final LocalDate departDate, returnDate; // returnDate null = một chiều private final int adults, children; private final Cabin cabin; private final List<String> airlines; private FlightSearch(Builder b) { this.from = b.from; this.to = b.to; this.departDate = b.departDate; this.returnDate = b.returnDate; this.adults = b.adults; this.children = b.children; this.cabin = b.cabin; this.airlines = List.copyOf(b.airlines); // bản sao bất biến: builder sửa tiếp cũng không ảnh hưởng } public static Builder builder(String from, String to, LocalDate departDate) { // tham số bắt buộc return new Builder(from, to, departDate); } public static final class Builder { private final String from, to; private final LocalDate departDate; private LocalDate returnDate; private int adults = 1, children = 0; private Cabin cabin = Cabin.ECONOMY; private final List<String> airlines = new ArrayList<>(); private Builder(String from, String to, LocalDate departDate) { this.from = Objects.requireNonNull(from, "from"); this.to = Objects.requireNonNull(to, "to"); this.departDate = Objects.requireNonNull(departDate, "departDate"); } public Builder returnOn(LocalDate d) { this.returnDate = d; return this; } public Builder adults(int n) { this.adults = n; return this; } public Builder children(int n) { this.children = n; return this; } public Builder cabin(Cabin c) { this.cabin = Objects.requireNonNull(c); return this; } public Builder airline(String code) { this.airlines.add(code); return this; } public FlightSearch build() { // ràng buộc giữa nhiều field kiểm tra ở một chỗ List<String> errors = new ArrayList<>(); if (from.equals(to)) errors.add("from == to"); if (returnDate != null && returnDate.isBefore(departDate)) errors.add("returnDate < departDate"); if (adults < 1) errors.add("adults >= 1"); if (children < 0 || adults + children > 9) errors.add("tổng hành khách 1..9"); if (children > 2 * adults) errors.add("mỗi người lớn kèm tối đa 2 trẻ em"); if (!errors.isEmpty()) throw new IllegalArgumentException(String.join("; ", errors)); return new FlightSearch(this); } } @Override public String toString() { return from + "→" + to + " " + departDate + (returnDate == null ? " (một chiều)" : " ↩ " + returnDate) + ", " + adults + "NL " + children + "TE, " + cabin + (airlines.isEmpty() ? "" : ", " + airlines); } public static void main(String[] args) { LocalDate d = LocalDate.of(2026, 12, 20); System.out.println(FlightSearch.builder("HAN", "SGN", d).build()); System.out.println(FlightSearch.builder("HAN", "DAD", d).returnOn(d.plusDays(4)) .adults(2).children(1).cabin(Cabin.BUSINESS).airline("VN").airline("VJ").build()); try { FlightSearch.builder("HAN", "HAN", d).returnOn(d.minusDays(1)).adults(1).children(3).build(); } catch (IllegalArgumentException e) { System.out.println("lỗi: " + e.getMessage()); } }}
HAN→SGN 2026-12-20 (một chiều), 1NL 0TE, ECONOMYHAN→DAD 2026-12-20 ↩ 2026-12-24, 2NL 1TE, BUSINESS, [VN, VJ]lỗi: from == to; returnDate < departDate; mỗi người lớn kèm tối đa 2 trẻ em
Ba quyết định đáng nói khi phỏng vấn: tham số bắt buộc nằm ở builder(...) nên không thể quên; List.copyOf để object không bị builder sửa sau khi tạo; gom mọi lỗi để client sửa một lần (giống validate DTO trả hết lỗi field).
Bài 2: phá rồi vá một singleton
Đề: viết Registry singleton (private static final INSTANCE, constructor private, implements Serializable, Cloneable). Chứng minh tạo được instance thứ hai bằng reflection, serialization và clone. Sau đó viết SafeRegistry chặn cả ba và so với một enum.
Lời giải Bài 2
import java.io.*;public class Registry implements Serializable, Cloneable { private static final Registry INSTANCE = new Registry(); private Registry() {} public static Registry getInstance() { return INSTANCE; } @Override public Registry clone() throws CloneNotSupportedException { return (Registry) super.clone(); }}
import java.io.*;public final class SafeRegistry implements Serializable { private static final SafeRegistry INSTANCE = new SafeRegistry(); private static boolean created; private SafeRegistry() { synchronized (SafeRegistry.class) { if (created) throw new IllegalStateException("SafeRegistry đã có instance"); created = true; } } public static SafeRegistry getInstance() { return INSTANCE; } @Serial private Object readResolve() { return INSTANCE; } // deserialize trả về bản đang có // không implement Cloneable: Object.clone() sẽ ném CloneNotSupportedException}
Hai điểm tinh ý: exception từ constructor đi qua reflection bị bọc trong InvocationTargetException; và readResolve phải trả Object, khai báo private là đủ (đánh dấu @Serial để compiler kiểm tra chữ ký). Lớp phòng thủ cuối cùng vẫn là enum, như pitfall ở mục 5.
Ghi nhớ
Kể được bốn lợi thế của static factory method và quy ước đặt tên của nó.
Biết khi nào builder đáng công hơn constructor hoặc record, và kiểm tra ràng buộc nằm ở đâu.
So được năm cách viết singleton, và giải thích vì sao trong Spring nên dùng bean.
Nêu được bốn cách phá singleton và cách chống từng cách.
Giải thích được vì sao không dùng finalize và clone, và thay bằng gì.
Câu hỏi phỏng vấn
Static factory method có lợi gì so với constructor? Có nhược điểm không?
Có tên, không bắt buộc tạo object mới (cache), được trả về lớp con hoặc cài đặt ẩn, và lớp trả về có thể được chọn lúc chạy.
Ví dụ: Integer.valueOf cache -128..127; EnumSet.noneOf chọn RegularEnumSet hay JumboEnumSet theo số hằng; List.of trả class nội bộ khác nhau. Nhược điểm: class chỉ có constructor private thì không kế thừa được (với class bất biến thường là ưu điểm), và static factory khó tìm trong tài liệu hơn constructor, nên dùng tên theo quy ước (of, from, valueOf, getInstance, newInstance).
Khi nào dùng Builder? So với telescoping constructor và JavaBeans?
Khi object có nhiều tham số, nhiều cái tuỳ chọn hoặc cùng kiểu dễ nhầm thứ tự, và có ràng buộc giữa các field cần kiểm tra cùng lúc.
Telescoping constructor khó đọc và nhầm thứ tự vẫn biên dịch được. JavaBeans để object ở trạng thái dở dang giữa các setter và không bất biến được. Builder: tham số bắt buộc ở builder(...), tuỳ chọn có tên, build() kiểm tra rồi tạo object bất biến. Với ít field, record hoặc static factory gọn hơn.
Có những cách nào viết singleton thread-safe? Bạn chọn cách nào?
Field static final khởi tạo sẵn, holder idiom (lazy, không lock), double-checked locking với volatile, và enum một hằng; trong Spring thì dùng bean scope singleton.
Thread-safety của ba cách đầu (trừ DCL) đến từ việc JVM khởi tạo class đúng một lần dưới lock. Ngoài container, mình chọn enum nếu cần chống reflection/serialization, holder idiom nếu cần lazy. Trong Spring, bean được inject nên test thay được, còn singleton tĩnh là global state khó mock.
Làm sao phá một singleton? Chống thế nào?
Bốn cách: reflection gọi constructor private, deserialize tạo object mới, clone() nếu class Cloneable, và nạp class bằng hai ClassLoader khác nhau.
Chống: constructor kiểm tra cờ và ném exception (chặn được dùng nhầm, không tuyệt đối); readResolve() trả INSTANCE; không implement Cloneable hoặc override clone() ném exception; đặt class ở loader dùng chung. Enum một hằng chống được reflection và serialization ở mức JVM. Nếu “duy nhất” là yêu cầu nghiệp vụ trên nhiều pod, đặt bảo đảm ở database hoặc khoá phân tán.
Singleton của Spring khác singleton pattern thế nào?
Singleton pattern là một instance mỗi ClassLoader (thực tế là mỗi JVM) do chính class tự đảm bảo; bean singleton của Spring là một instance mỗi container và mỗi định nghĩa bean, do container quản lý.
Hệ quả: hai ApplicationContext có hai instance; khai báo hai @Bean cùng kiểu là hai instance; class vẫn có constructor bình thường và test tạo được bằng new. Cả hai đều dùng chung giữa các thread nên không nên có trạng thái thay đổi, hoặc trạng thái đó phải thread-safe.
Vì sao không nên dùng finalize()? Dùng gì thay?
Vì không biết khi nào (hay có) chạy, chạy trên thread lạ, kéo dài đời object qua thêm một chu kỳ GC và từng gây lỗ hổng bảo mật; nó đã deprecated để xoá từ JDK 18.
Thay bằng: implement AutoCloseable và đóng bằng try-with-resources; nếu class bọc tài nguyên native, đăng ký Cleaner làm lưới an toàn khi người dùng quên close(), nhưng không coi nó là cơ chế chính.
clone() có vấn đề gì? Bạn chép object thế nào?
Cloneable không có method, Object.clone() là protected, ném checked exception, chép nông và không làm việc được với field final trỏ tới object mutable.
Dùng copy constructor (new Itinerary(other)) hoặc copy factory (Itinerary.copyOf(other)), chép sâu đúng phần mutable. Mảng thì array.clone() vẫn ổn. Tốt nhất là thiết kế class bất biến để không cần chép.
Tránh tạo object không cần thiết nghĩa là gì? Có nên tự viết object pool không?
Nghĩa là tránh boxing ở hot path, dựng một lần object đắt (Pattern, ObjectMapper) và dùng valueOf/literal cho kiểu bất biến; không có nghĩa là né new.
Cấp phát object nhỏ trong Java rất rẻ nhờ TLAB và GC thế hệ, nên object pool tự viết cho object nhẹ thường chậm hơn và thêm lỗi đồng bộ, còn làm object sống lâu lên old generation. Pool chỉ đáng cho tài nguyên đắt hoặc có giới hạn bên ngoài: connection database, thread. Đo trước khi tối ưu: cộng dồn bằng Long chậm hơn long khoảng 5 lần là con số đáng sửa; một new trong request thì không.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu tiếng Anh dùng trong phỏng vấn
static factory method
/ˈstæt.ɪk ˈfæk.tɚ.i ˈmeθ.əd/
method static trả instance
“A static factory can return a cached instance instead of a new one.”
telescoping constructor
/ˈtel.ə.skoʊ.pɪŋ kənˈstrʌk.tɚ/
chuỗi constructor thêm dần tham số
“Telescoping constructors make it easy to swap two int arguments.”
builder
/ˈbɪl.dɚ/
đối tượng dựng object từng bước
“The builder validates cross-field rules in build().”
utility class
/juːˈtɪl.ə.t̬i klæs/
class chỉ có method static
“A utility class gets a private constructor that throws.”
holder idiom
/ˈhoʊl.dɚ ˈɪd.i.əm/
singleton lười nhờ class lồng
“The holder idiom is lazy and needs no explicit locking.”
enum singleton
/ˈiː.nʌm ˈsɪŋ.ɡəl.tən/
singleton bằng enum một hằng
“An enum singleton is safe against reflection and serialization.”
readResolve
/riːd rɪˈzɑːlv/
method thay object khi deserialize
“readResolve returns the existing instance after deserialization.”
obsolete reference
/ˌɑːb.səˈliːt ˈref.ɚ.əns/
tham chiếu không còn cần
“Nulling out obsolete references matters when a class manages its own memory.”
copy constructor
/ˈkɑː.pi kənˈstrʌk.tɚ/
constructor nhận object cùng kiểu để chép
“I prefer a copy constructor to clone().”
object pool
/ˈɑːb.dʒekt puːl/
kho object dùng lại
“Pooling cheap objects usually hurts; pooling connections helps.”
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.