Cụm bài Enum và nested class: 1. Enum là một class · 2. Enum ở production · 3. Nested class và lambda
Chọn sai loại nested class có hệ quả thật: một inner class đăng ký làm listener có thể giữ một object 50 MB mãi không được thu hồi. Đọc xong, bạn chọn đúng giữa static nested, inner, local, anonymous class, lambda và record, và giải thích được effectively final. Bài tập gồm Lab 07 của tài liệu Hỏi Dân IT với lời giải đầy đủ; không cần đọc phần 1 trước vì enum OrderStatus được viết lại ở đây. Code dùng Java 21.
1. Nested class: bốn loại
Ý chính: bốn loại khác nhau ở hai điểm: có gắn với một instance của outer class không, và dùng được ở phạm vi nào. Mặc định chọn static nested.
| Loại | Khai báo ở đâu | Gắn với outer instance | Truy cập được | Dùng điển hình |
|---|---|---|---|---|
| Static nested class | Trong thân class, có static |
Không | Static member của outer (kể cả private) |
Builder, node của cấu trúc dữ liệu, DTO phụ |
| Inner class | Trong thân class, không static |
Có (Outer.this) |
Mọi member của outer instance | Iterator của collection, view lên dữ liệu outer |
| Local class | Trong method/khối lệnh, có tên | Có, nếu ở ngữ cảnh non-static | Outer + biến cục bộ effectively final | Helper dùng nhiều lần trong một method |
| Anonymous class | Ngay trong biểu thức new, không tên |
Có, nếu ở ngữ cảnh non-static | Như local class | Implement một interface/class một lần |
Record, enum và interface khai báo lồng (kể cả trong method, từ Java 16) đều ngầm là static.
flowchart TD
A["Cần một kiểu phụ cho class này"] --> B{"Chỉ là một hàm của interface có 1 method?"}
B -->|Có| L["Lambda hoặc method reference"]
B -->|Không| C{"Cần đọc state của một outer instance cụ thể?"}
C -->|Không| D{"Là dữ liệu bất biến?"}
D -->|Có| R["Record lồng (ngầm static)"]
D -->|Không| S["Static nested class"]
C -->|Có| E{"Chỉ dùng trong một method?"}
E -->|Không| I["Inner class"]
E -->|"Có, dùng 1 lần"| AN["Anonymous class"]
E -->|"Có, dùng nhiều lần"| LC["Local class"]
1.1. Static nested class
Ý chính: static nested class là một class top-level đặt trong namespace của class khác. Nó không giữ tham chiếu tới outer instance, nhưng truy cập được member private của outer (và ngược lại).
Ví dụ kinh điển là Builder:
public final class HttpCall {
private final String url;
private final String method;
private final Map<String, String> headers;
private final Duration timeout;
private HttpCall(Builder b) {
this.url = b.url;
this.method = b.method;
this.headers = Map.copyOf(b.headers);
this.timeout = b.timeout;
}
public static Builder to(String url) { return new Builder(url); }
public static final class Builder {
private final String url;
private String method = "GET";
private final Map<String, String> headers = new LinkedHashMap<>();
private Duration timeout = Duration.ofSeconds(5);
private Builder(String url) { this.url = Objects.requireNonNull(url, "url"); }
public Builder method(String method) { this.method = method; return this; }
public Builder header(String name, String value) { headers.put(name, value); return this; }
public Builder timeout(Duration timeout) { this.timeout = timeout; return this; }
public HttpCall build() { return new HttpCall(this); }
}
}
HttpCall call = HttpCall.to("https://api.example.com/orders")
.method("POST")
.header("Content-Type", "application/json")
.build();
Builder phải là static: lúc dùng builder thì chưa có HttpCall nào để làm outer instance. Ví dụ khác trong JDK: HashMap.Node, Map.Entry, AbstractMap.SimpleEntry.
1.2. Inner class và tham chiếu ẩn tới outer
Ý chính: inner class (non-static) gắn với một outer instance: phải có outer object mới tạo được nó, và nó dùng field của outer như của chính mình. Cái giá là mỗi inner object giữ một tham chiếu mạnh tới outer.
public class Playlist {
private final List<String> songs = new ArrayList<>();
private int version;
public class Cursor {
private int index;
private final int expectedVersion = version; // đọc field của outer
public String next() {
if (version != expectedVersion) throw new ConcurrentModificationException();
return songs.get(index++); // tương đương Playlist.this.songs
}
}
}
Playlist playlist = new Playlist();
Playlist.Cursor cursor = playlist.new Cursor(); // cú pháp outer.new Inner()
- Compiler thêm vào inner class một field ẩn
final Playlist this$0và một tham số ẩn cho constructor. - Đây là cách
ArrayList.iterator()hoạt động (ArrayList.Itrlà inner class). Dùng inner đúng chỗ: object phụ chỉ có nghĩa khi gắn với object chính. - Từ Java 16, inner class được khai báo static member (trước đó là lỗi biên dịch).
JDK 18 bỏ this$0 khi không dùng outer, và ngoại lệ Serializable
1.3. Local class
Ý chính: local class khai báo trong method hoặc khối lệnh, có tên, chỉ dùng trong phạm vi đó. Nó đọc được field của outer và biến cục bộ effectively final (gán đúng một lần).
void exportReport(List<Order> orders, String tenant) {
class Row {
final String id;
final String amount;
Row(Order o) {
this.id = tenant + "-" + o.id(); // dùng biến cục bộ của method
this.amount = o.total().toPlainString();
}
String toCsv() { return id + "," + amount; }
}
orders.stream().map(Row::new).map(Row::toCsv).forEach(System.out::println);
}
Local class ít gặp trong code hiện đại, vì đã có lambda hoặc local record thay thế. Lưu ý: local record, local enum và local interface (Java 16+) ngầm là static, nên không đọc được biến cục bộ hay this của method bao quanh.
Ví dụ record R(int v) { String show() { return prefix + v; } } với prefix là biến cục bộ là lỗi biên dịch. Muốn dùng giá trị đó, truyền nó vào làm component của record.
1.4. Anonymous class
Ý chính: anonymous class khai báo và tạo instance trong cùng một biểu thức, không tên. Nó implement một interface hoặc extends một class (kể cả abstract), có field và nhiều method.
Comparator<Order> byTotalDesc = new Comparator<>() {
@Override
public int compare(Order a, Order b) {
return b.total().compareTo(a.total());
}
};
Trước Java 8, đây là cách duy nhất để truyền “một hàm” đi. Nay với interface một abstract method, lambda thay gần hết. Anonymous class còn chỗ đứng khi cần extends abstract class, implement interface nhiều method, hoặc cần state riêng.
2. Effectively final: vì sao lambda và anonymous class chỉ đọc được biến cục bộ “gán một lần”
Ý chính: lambda có thể chạy sau khi method đã return, thậm chí trên thread khác, nên compiler sao chép giá trị biến cục bộ vào nó. Cho gán lại thì bản sao và bản gốc lệch nhau, nên Java cấm luôn.
Biến cục bộ sống trên stack của method; bản sao nằm trong object lambda (thành field hoặc tham số ẩn). Quy tắc áp dụng cho lambda, anonymous class và local class.
int count = 0;
Runnable r = () -> count++; // lỗi: local variables referenced from a lambda expression
// must be final or effectively final
Quy tắc chỉ áp dụng cho biến cục bộ. Field của object thì đọc ghi thoải mái, vì lambda giữ this chứ không sao chép field. Xem ví dụ cơ bản ở Java cơ bản phần 2.
3. Anonymous class và lambda khác nhau thế nào
Ý chính: lambda không phải “cú pháp ngắn của anonymous class”. Khác nhau ở this, ở kiểu đích, ở state, và ở cách JVM chạy chúng.
| Khía cạnh | Anonymous class | Lambda |
|---|---|---|
this |
Chính object anonymous class | Object của class bao quanh (lexical scope) |
| Target | Interface bất kỳ hoặc class (kể cả abstract) | Chỉ functional interface (một abstract method) |
| State, nhiều method | Có field, nhiều method, initializer | Không có field riêng |
| Giữ outer | Luôn có nếu dùng outer (và luôn có nếu class Serializable) | Chỉ khi thân lambda dùng this, field hoặc method instance |
Khác biệt về this thấy rõ nhất khi chạy thử:
class Demo {
void run() {
Runnable anon = new Runnable() {
public void run() { System.out.println(this.getClass().getName()); } // Demo$1
};
Runnable lambda = () -> System.out.println(this.getClass().getName()); // Demo
anon.run();
lambda.run();
}
}
Scope tên biến, biên dịch, instance, serialization và hiệu năng
| Khía cạnh | Anonymous class | Lambda |
|---|---|---|
| Phạm vi tên biến | Scope mới, được khai báo trùng tên biến bên ngoài (shadowing) | Cùng scope với method bao quanh, khai báo trùng tên là lỗi |
| Biên dịch | Một file .class riêng (Outer$1.class) cho mỗi chỗ khai báo |
Thân lambda thành private method trong class bao quanh; class thật được sinh lúc runtime qua invokedynamic + LambdaMetafactory |
| Instance | Mỗi lần biểu thức chạy là một object mới | Lambda không capture gì thường được dùng lại một instance (chi tiết cài đặt của HotSpot, không được đặc tả); lambda có capture tạo object mới |
| Serialization | Serializable nếu kiểu cha Serializable, kéo theo cả outer | Chỉ khi target type Serializable ((Runnable & Serializable) () -> ...); dạng serialize phụ thuộc tên method do compiler sinh, rất dễ vỡ, không nên dùng |
Hiệu năng: anonymous class tốn chi phí load một class riêng cho mỗi chỗ khai báo; ứng dụng có hàng nghìn anonymous class sẽ thấy rõ ở thời gian khởi động và metaspace. Lambda tốn một lần bootstrap invokedynamic ở lần chạy đầu, sau đó rẻ. Trong code nghiệp vụ thông thường, chênh lệch này không đáng để chọn theo hiệu năng; chọn theo ngữ nghĩa.
4. Khi nào dùng record và sealed interface thay vì nested class hay enum
Ý chính: nhiều nested class cũ chỉ là “túi dữ liệu” (field private final, constructor, getter, equals/hashCode). Từ Java 16, việc đó là của record.
public class PricingService {
// Thay cho một static nested class 30 dòng
record Quote(String sku, BigDecimal unitPrice, int quantity) {
Quote {
if (quantity <= 0) throw new IllegalArgumentException("quantity must be > 0");
}
BigDecimal total() { return unitPrice.multiply(BigDecimal.valueOf(quantity)); }
}
}
| Cần gì | Dùng |
|---|---|
| Dữ liệu bất biến, so sánh theo giá trị | record (lồng trong class nếu chỉ class đó dùng, hoặc local record) |
| Tập giá trị cố định, cùng hình dạng | enum |
| Tập trường hợp cố định, mỗi trường hợp mang dữ liệu riêng | sealed interface + record |
| Object có state thay đổi và hành vi, không phụ thuộc outer | static nested class (hoặc top-level nếu dùng rộng) |
| Object phụ gắn chặt với một outer instance (iterator, view) | inner class |
| Hàm truyền đi một lần | lambda hoặc method reference |
Bài tập
1. Lab 07: bốn loại nested class trong một đơn hàng (và chỗ nào nên sửa)
Đề (diễn giải): class Order có id và trạng thái. Trong method xử lý đơn, dùng một local class để log; một inner class giữ tên và số điện thoại khách, in kèm trạng thái đơn; một static nested class tính chiết khấu theo trạng thái (đang giao 10%, đã giao/đã huỷ 0%, còn lại 5%); và trong main, một anonymous Runnable in ra đơn đang được xử lý ở trạng thái nào. Enum trạng thái có mô tả tiếng Việt và method cho biết đó có phải trạng thái cuối (đã giao hoặc đã huỷ) không.
Lời giải Lab 07 và review như code thật
Một file chạy được bằng java Lab07.java. Cuối main có thêm hai dòng để thấy cú pháp outer.new Inner() từ bên ngoài và bảng chiết khấu của mọi trạng thái.
import java.math.BigDecimal;
public class Lab07 {
enum OrderStatus {
PENDING("Chờ xác nhận"),
SHIPPED("Đang giao hàng"),
DELIVERED("Đã giao"),
CANCELLED("Đã huỷ");
private final String label;
OrderStatus(String label) { this.label = label; }
String label() { return label; }
boolean isFinal() { return this == DELIVERED || this == CANCELLED; }
}
static class Order {
private final String id;
private OrderStatus status;
private final CustomerInfo customer;
Order(String id, OrderStatus status, String name, String phone) {
this.id = id;
this.status = status;
this.customer = new CustomerInfo(name, phone); // trong outer thì không cần this.new
}
class CustomerInfo { // inner: đọc status của outer
private final String name;
private final String phone;
CustomerInfo(String name, String phone) { this.name = name; this.phone = phone; }
void printInfo() {
System.out.println("Customer: " + name + " - " + phone + " | order status: " + status.label());
}
}
static class DiscountHelper { // static nested: không cần outer
private DiscountHelper() {}
static BigDecimal discountRate(OrderStatus status) {
return switch (status) {
case SHIPPED -> new BigDecimal("0.10");
case DELIVERED, CANCELLED -> BigDecimal.ZERO;
case PENDING -> new BigDecimal("0.05");
};
}
}
void process() {
class Logger { // local class: đọc id của outer
void log(String message) { System.out.println("[LOG] order " + id + " - " + message); }
}
Logger logger = new Logger();
logger.log("start processing, status: " + status.label());
customer.printInfo();
System.out.println("Discount: "
+ DiscountHelper.discountRate(status).movePointRight(2).stripTrailingZeros().toPlainString() + "%");
System.out.println("Final status: " + status.isFinal());
}
String id() { return id; }
OrderStatus status() { return status; }
}
public static void main(String[] args) {
Order order = new Order("A001", OrderStatus.PENDING, "Lan", "0900000000");
order.process();
Runnable task = new Runnable() { // anonymous class
@Override
public void run() {
System.out.println("Order " + order.id() + " is being processed in status: " + order.status().label());
}
};
task.run();
Order.CustomerInfo other = order.new CustomerInfo("Minh", "0911111111"); // tạo inner từ bên ngoài: outer.new
other.printInfo();
for (OrderStatus s : OrderStatus.values()) {
System.out.println(s + " -> " + Order.DiscountHelper.discountRate(s));
}
}
}
[LOG] order A001 - start processing, status: Chờ xác nhận
Customer: Lan - 0900000000 | order status: Chờ xác nhận
Discount: 5%
Final status: false
Order A001 is being processed in status: Chờ xác nhận
Customer: Minh - 0911111111 | order status: Chờ xác nhận
PENDING -> 0.05
SHIPPED -> 0.10
DELIVERED -> 0
CANCELLED -> 0
Code chạy đúng, nhưng là bài tập cú pháp. Nếu review như code thật, mình sẽ sửa:
- Tỷ lệ chiết khấu là thuộc tính của trạng thái, nên đưa vào enum (
SHIPPED("Đang giao hàng", new BigDecimal("0.10"))) thay vì helper class với switch. Switch exhaustive ít ra bắt thiếu hằng lúc build; một chuỗiifvớielsetrả 5% thì không. DùngBigDecimalchứ khôngdoublecho tiền. CustomerInfokhông cần đọc trạng thái đơn: khách hàng là dữ liệu bất biến, nên làrecord CustomerInfo(String name, String phone); in kèm trạng thái là việc củaOrder. Inner class ở đây khiến mỗiCustomerInfogiữ ngầm mộtOrder.- Local class
Loggernên là một logger thật (SLF4J) dạng fieldprivate static final. - Anonymous
Runnableviết lại bằng lambda:Runnable task = () -> System.out.println(...);. Biếnorderlà effectively final nên capture được.
2. Builder bằng static nested class có validation
Đề: viết class bất biến mô tả một lời gọi HTTP (url bắt buộc, method mặc định GET, header, timeout mặc định 5 giây) với builder; builder phải chặn timeout không dương và chặn request GET khai báo Content-Type.
Lời giải Bài 2: validation trong setter và trong build()
Dùng class HttpCall ở mục 1.1, thêm validation vào builder. Kiểm tra từng tham số ngay trong setter (lỗi sớm, rõ ràng), kiểm tra ràng buộc giữa nhiều field trong build().
public Builder timeout(Duration timeout) {
if (timeout.isNegative() || timeout.isZero()) throw new IllegalArgumentException("timeout must be > 0");
this.timeout = timeout;
return this;
}
public HttpCall build() {
if (method.equals("GET") && headers.containsKey("Content-Type")) {
throw new IllegalStateException("GET request should not declare a body type");
}
return new HttpCall(this);
}
Vì sao static: builder tồn tại trước HttpCall, nên không thể có outer instance. Constructor HttpCall(Builder) là private, chỉ builder gọi được (nested class truy cập được member private của outer). Map.copyOf trong constructor đảm bảo sửa builder sau build() không làm đổi object đã tạo.
3. Tìm và sửa rò rỉ bộ nhớ
Đề: một job sinh báo cáo giữ buffer lớn, đăng ký một listener là inner class vào event bus tĩnh để đếm số sự kiện. Sau vài giờ chạy, service bị OutOfMemoryError. Giải thích và sửa.
Lời giải Bài 3: listener static nested và handle huỷ đăng ký
Inner class OnPriceChanged dùng field handled của outer nên có this$0 trỏ tới ReportJob. Event bus tĩnh giữ listener mãi, nên mọi ReportJob (cùng buffer 50 MB) không bao giờ được thu hồi. Đổi sang lambda e -> handled++ cũng không cứu được vì lambda đó vẫn capture this. Sửa hai tầng: listener không giữ outer, và luôn huỷ đăng ký.
static final class EventBus {
private static final List<Consumer<String>> LISTENERS = new CopyOnWriteArrayList<>();
static Runnable subscribe(Consumer<String> listener) {
LISTENERS.add(listener);
return () -> LISTENERS.remove(listener); // trả về cách huỷ đăng ký
}
}
static class ReportJob implements AutoCloseable {
private final byte[] buffer = new byte[50 * 1024 * 1024];
private final AtomicInteger handled = new AtomicInteger();
private Runnable unsubscribe;
static final class OnPriceChanged implements Consumer<String> { // static: không có this$0
private final AtomicInteger counter;
OnPriceChanged(AtomicInteger counter) { this.counter = counter; }
@Override public void accept(String event) { counter.incrementAndGet(); }
}
void start() { unsubscribe = EventBus.subscribe(new OnPriceChanged(handled)); }
@Override
public void close() { if (unsubscribe != null) unsubscribe.run(); }
}
try (ReportJob job = new ReportJob()) {
job.start();
// ...
}
Mình đã chạy bản lỗi với -Xmx512m: tạo 100 job là OutOfMemoryError. Bản sửa chỉ giữ lại listener nhỏ và AtomicInteger, buffer được thu hồi. Thực tế, tìm loại lỗi này bằng heap dump (jcmd <pid> GC.heap_dump) rồi xem “path to GC roots” của object bị giữ trong Eclipse MAT hoặc IntelliJ.
Ghi nhớ
- Giải thích được vì sao mặc định nên dùng static nested, và vì sao Builder bắt buộc là static.
- Chỉ ra được đường giữ
static field -> listener -> this$0 -> outervà hai cách sửa. - Giải thích được vì sao biến cục bộ trong lambda phải effectively final, còn field thì không.
- Biết
thistrỏ tới đâu trong lambda và trong anonymous class, và khi nào vẫn cần anonymous class. - Biết khi nào thay nested class bằng record hoặc sealed interface + record.
Câu hỏi phỏng vấn
Junior
Static nested class và inner class khác nhau thế nào?
Static nested không gắn với outer instance nào; inner class gắn với một outer instance và giữ tham chiếu ẩn tới nó.
Static nested tạo bằng new Outer.Nested(), chỉ dùng được static member của outer. Inner class tạo bằng outer.new Inner(), dùng được mọi field của outer. Mặc định nên dùng static nested, chỉ dùng inner khi thật sự cần state của outer.
Tạo object inner class từ bên ngoài outer class thế nào? Local class khác anonymous class ở đâu?
Từ bên ngoài cần một outer object: order.new CustomerInfo(...). Local class có tên và dùng lại được; anonymous class không tên và chỉ dùng một lần.
Trong method instance của outer chỉ cần new CustomerInfo(...) (ngầm là this.new). Local class khai báo trong method, có constructor và dùng lại nhiều lần trong method đó. Anonymous class khai báo và tạo instance trong cùng một biểu thức, không có constructor riêng (dùng instance initializer), và chỉ extends một class hoặc implement một interface.
Mid
Trong lambda và trong anonymous class, this trỏ tới đâu?
Trong anonymous class, this là chính object đó; trong lambda, this là object của class bao quanh.
Lambda không tạo scope mới (cũng vì thế không được khai báo biến trùng tên biến cục bộ bên ngoài). Hệ quả: muốn handler tự huỷ đăng ký bằng unsubscribe(this) thì cần anonymous class; còn toString() gọi trong lambda là của class bao quanh.
Vì sao biến cục bộ dùng trong lambda phải effectively final?
Vì lambda nhận bản sao giá trị của biến, không phải biến; cho gán lại thì bản sao và bản gốc lệch nhau.
Lambda có thể chạy sau khi method đã return, hoặc trên thread khác, trong khi biến cục bộ nằm trên stack. Java cấm gán lại để tránh lệch và race condition. Field không bị giới hạn vì lambda giữ this. Lách bằng mảng một phần tử biên dịch được nhưng thường là sai thiết kế; với stream nên dùng reduce/collector.
Vì sao Builder thường là static nested class?
Vì builder tồn tại trước object nó tạo ra, nên không có outer instance để gắn vào.
Viết thành inner class thì phải có sẵn một object mới tạo được builder, vô lý. Là nested class, builder gọi được constructor private của outer, nên chỉ builder tạo được object và mọi validation đi qua nó. Nó nằm trong namespace của outer (HttpCall.Builder), và vì static nên không giữ tham chiếu ẩn tới object nào.
Senior
Mô tả một tình huống inner class hoặc lambda gây rò rỉ bộ nhớ trong backend, và cách bạn tìm ra nó.
Listener là inner class hay lambda dùng field, đăng ký vào event bus tĩnh hay executor mà không huỷ, giữ outer object lớn mãi. Tìm bằng heap dump và path to GC roots.
- Tình huống: object xử lý báo cáo giữ dữ liệu lớn, đăng ký listener vào event bus tĩnh, hoặc submit vào scheduled executor chạy định kỳ mà không huỷ. Listener giữ
this$0hoặcthis, nên object lớn không bao giờ được GC. - Triệu chứng: heap sau mỗi full GC tăng dần, cuối cùng OOM.
- Tìm: heap dump, xem dominator tree và path to GC roots, thấy chuỗi
static field -> listener -> this$0 -> object lớn. - Sửa: listener là static nested class chỉ giữ thứ nó cần, luôn huỷ đăng ký (trả về handle
AutoCloseable), hoặc dùng tham chiếu yếu khi phù hợp.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| nested class | /ˈnestɪd klæs/ | class lồng | “I default to a static nested class unless I really need the outer instance.” |
| inner class | /ˈɪnər klæs/ | class lồng non-static | “An inner class keeps an implicit reference to its enclosing instance.” |
| enclosing instance | /ɪnˈkloʊzɪŋ ˈɪnstəns/ | object bao ngoài | “The iterator needs the enclosing instance to read the list’s elements.” |
| anonymous class | /əˈnɑːnɪməs klæs/ | class vô danh | “I’d only use an anonymous class if I need state or to extend an abstract class.” |
| effectively final | /ɪˈfektɪvli ˈfaɪnl/ | gán đúng một lần | “Captured local variables must be effectively final.” |
| capture | /ˈkæptʃər/ | giữ lại (biến) trong closure | “This lambda captures this, so it keeps the whole service alive.” |
| memory leak | /ˈmeməri liːk/ | rò rỉ bộ nhớ | “The static listener list caused a memory leak through the inner class.” |
| path to GC roots | /pæθ tə ˌdʒiː ˈsiː ruːts/ | đường giữ object từ GC root | “The heap dump showed the path to GC roots going through this$0.” |
Ghi chép dựa trên tài liệu Java Core của Hỏi Dân IT và kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.