Cụm bài Enum và nested class: 1. Enum là một class · 2. Enum ở production · 3. Nested class và lambda
Enum hay bị xem là “cú pháp phụ” để khai báo vài hằng, nhưng dùng sai thì hỏng thật ở production. Đọc xong, bạn thiết kế được enum như một class (field, method, strategy), tránh bẫy của valueOf/values()/ordinal(), dùng switch đủ trường hợp, và biết khi nào cần sealed interface cộng record thay cho enum. Nên nắm class, constructor, static và final trước (OOP phần 1, phần 2); code dùng Java 21.
Sơ đồ tóm tắt:
flowchart TD
Q{Mọi giá trị cùng hình dạng?} -->|có| E["Enum: tập giá trị đóng"]
Q -->|không| SI["Sealed interface + record"]
E --> C["Hằng duy nhất, so bằng =="]
E --> F["Field, method, thân riêng"]
E --> V["Input ngoài: Map + Optional"]
V -.-> ST["Bảng tra trong static {}"]
E --> SW["Switch không default"]
Hai phần sau của cụm bài nói về enum ở biên hệ thống và nested class. Phần 2: EnumSet/EnumMap, enum singleton, enum ở database, JSON, API (lưu sai cách thì chèn một hằng vào giữa làm sai cả dữ liệu cũ; thêm hằng vào enum của API làm client cũ chết khi deserialize). Phần 3: bốn loại nested class, effectively final và lambda (một inner class làm listener có thể giữ cả object 50 MB không bao giờ được thu hồi).
1. Từ hằng số static final đến enum
Ý chính: hằng String/int để compiler nhận mọi chuỗi hay số bất kỳ. Enum là một kiểu riêng, nên chỉ các giá trị đã khai báo mới biên dịch được.
public final class Roles {
public static final String ADMIN = "ADMIN";
public static final String EDITOR = "EDITOR";
public static final String VIEWER = "VIEWER";
private Roles() {}
}
void grant(String role) { ... }
grant(Roles.ADMIN); // đúng ý
grant("SUPERADMIN"); // vẫn biên dịch được
grant("admin"); // vẫn biên dịch được, nhưng sai chữ hoa
Dùng int (static final int ADMIN = 1) còn tệ hơn: log in ra số 1 không ai hiểu, và grant(STATUS_ACTIVE) (hằng int của khái niệm khác) vẫn lọt qua.
public enum Role { ADMIN, EDITOR, VIEWER }
void grant(Role role) { ... }
grant(Role.ADMIN); // chỉ nhận được 3 giá trị này (hoặc null)
// grant("ADMIN"); // lỗi biên dịch
Ngoài an toàn kiểu, enum còn có toString() dễ đọc, so sánh bằng ==, switch kiểm tra đủ trường hợp, EnumSet/EnumMap chuyên dụng, và quan trọng nhất: gắn được dữ liệu và hành vi vào từng giá trị.
2. Enum là một class
Ý chính: compiler biến enum thành một class final kế thừa java.lang.Enum, mỗi hằng là một static final object tạo một lần. Vì vậy enum có field, constructor, method, và implement được interface.
2.1. Compiler sinh ra gì
enum Role { ADMIN, EDITOR, VIEWER } được biên dịch gần giống thế này:
public final class Role extends java.lang.Enum<Role> { // final nếu không hằng nào có thân riêng
public static final Role ADMIN = new Role("ADMIN", 0);
public static final Role EDITOR = new Role("EDITOR", 1);
public static final Role VIEWER = new Role("VIEWER", 2);
private static final Role[] $VALUES = { ADMIN, EDITOR, VIEWER };
private Role(String name, int ordinal) { super(name, ordinal); }
public static Role[] values() { return $VALUES.clone(); }
public static Role valueOf(String name) { return Enum.valueOf(Role.class, name); }
}
Các quy tắc suy ra từ đó:
- Mỗi hằng là một object duy nhất trong JVM (mỗi class loader), nên
==là đúng, và an toàn vớinullhơnequals. - Đã ngầm
extends Enum<E>nên không kế thừa được class khác, nhưng implement được interface. - Constructor luôn
private(viếtpubliclà lỗi biên dịch). Khôngnewđược, kể cả bằng reflection. Enumđã implementComparable(so theoordinal) vàSerializable;equals,hashCodelàfinal, dựa trên identity (danh tính object, không so nội dung).- Method có sẵn:
name()(tên đúng như khai báo,final),ordinal()(vị trí, từ 0),toString()(mặc định bằngname(), override được),compareTo,getDeclaringClass().
Enum<E extends Enum<E>> là một recursive generic bound (kiểu tự tham chiếu chính nó), xem bài generics.
2.2. Field, constructor và method
Field nên là final: hằng enum là singleton dùng chung toàn JVM, field thay đổi được tức là global mutable state (trạng thái toàn cục ai cũng sửa được).
public enum Priority {
LOW("Thấp", Duration.ofDays(3)),
MEDIUM("Trung bình", Duration.ofHours(24)),
HIGH("Cao", Duration.ofHours(4)),
CRITICAL("Khẩn cấp", Duration.ofMinutes(30));
private final String label;
private final Duration sla;
Priority(String label, Duration sla) { // ngầm là private
this.label = label;
this.sla = sla;
}
public String label() { return label; }
public Duration sla() { return sla; }
public boolean needsPaging() {
return this.compareTo(HIGH) >= 0; // HIGH và CRITICAL
}
}
Danh sách hằng phải đứng đầu tiên trong thân enum, kết thúc bằng ; nếu sau đó còn field hoặc method.
2.3. Thân riêng cho từng hằng (constant-specific body)
Mỗi hằng có thể có thân riêng, override method của enum. Enum thường khai báo một method abstract để buộc mọi hằng phải implement:
public enum ShippingMethod {
STANDARD {
@Override
public BigDecimal fee(BigDecimal weightKg) {
return new BigDecimal("15000").add(weightKg.multiply(new BigDecimal("3000")));
}
},
EXPRESS {
@Override
public BigDecimal fee(BigDecimal weightKg) {
return STANDARD.fee(weightKg).multiply(BigDecimal.TWO);
}
@Override
public boolean trackable() { return true; }
},
PICKUP {
@Override
public BigDecimal fee(BigDecimal weightKg) { return BigDecimal.ZERO; }
};
public abstract BigDecimal fee(BigDecimal weightKg);
public boolean trackable() { return false; }
}
So với một method chứa switch (this), logic của mỗi hằng nằm ngay cạnh hằng đó, và thêm hằng mới mà quên implement fee là lỗi biên dịch.
Hằng có thân riêng là anonymous subclass: getClass và getDeclaringClass
Hằng có thân riêng thực chất là một anonymous subclass (lớp con không tên) của enum. ShippingMethod.EXPRESS.getClass() trả về ShippingMethod$2, không phải ShippingMethod, và getClass().isEnum() là false. Code cần biết kiểu enum (ví dụ khi tự viết serializer) phải dùng getDeclaringClass(). Đây cũng là lý do class sinh ra không còn final khi có hằng mang thân riêng.
2.4. Implement interface và strategy bằng enum
Enum implement được interface, nên mỗi hằng là một strategy (một cách xử lý thay thế được) có sẵn, không cần tạo object:
public enum Operation implements DoubleBinaryOperator {
PLUS("+", (a, b) -> a + b),
MINUS("-", (a, b) -> a - b),
TIMES("*", (a, b) -> a * b),
DIVIDE("/", (a, b) -> a / b);
private final String symbol;
private final DoubleBinaryOperator impl;
Operation(String symbol, DoubleBinaryOperator impl) {
this.symbol = symbol;
this.impl = impl;
}
@Override
public double applyAsDouble(double a, double b) { return impl.applyAsDouble(a, b); }
private static final Map<String, Operation> BY_SYMBOL = new HashMap<>();
static {
for (Operation op : values()) BY_SYMBOL.put(op.symbol, op);
}
public static Optional<Operation> fromSymbol(String symbol) {
return Optional.ofNullable(BY_SYMBOL.get(symbol));
}
}
// Thay cho một chuỗi if (op.equals("+")) ... else if ...
double result = Operation.fromSymbol("*").orElseThrow().applyAsDouble(3, 4); // 12.0
- Lambda vào constructor gọn hơn khi các hằng chỉ khác nhau ở một biểu thức; thân riêng (mục 2.3) hợp hơn khi mỗi hằng override nhiều method hoặc logic dài.
- Phía gọi chỉ phụ thuộc
DoubleBinaryOperator, nên sau này thêm được một enum khác (ScientificOperation) cùng implement. Đó là cách “mở rộng” một tập giá trị vốn đóng.
3. values(), valueOf() và ordinal()
Ý chính: valueOf khớp chính xác tên và ném exception khi sai, nên đừng đưa input bên ngoài thẳng vào nó. ordinal() đổi khi ai đó sắp lại hằng, nên đừng dựa vào nó trong nghiệp vụ.
valueOf(String) phân biệt hoa thường, không trim, và ném exception chứ không trả null:
Color.valueOf("RED"); // RED
Color.valueOf("red"); // IllegalArgumentException: No enum constant Color.red
Color.valueOf(null); // NullPointerException: Name is null
Với input từ người dùng, query param hay file CSV, đừng để exception này thành lỗi 500. Tra cứu an toàn, chuẩn hoá đầu vào, trả Optional:
private static final Map<String, OrderStatus> BY_NAME = new HashMap<>();
static {
for (OrderStatus s : values()) BY_NAME.put(s.name(), s);
}
public static Optional<OrderStatus> parse(String raw) {
if (raw == null) return Optional.empty();
return Optional.ofNullable(BY_NAME.get(raw.strip().toUpperCase(Locale.ROOT)));
}
ordinal() là vị trí khai báo, phục vụ EnumSet/EnumMap bên trong JDK. Đổi thứ tự, chèn hằng vào giữa hay xoá một hằng đều làm ordinal của hằng khác đổi theo. Cần con số ổn định (mã gửi hệ thống khác, mức ưu tiên) thì khai báo field riêng.
values() cấp phát mảng mới, và compareTo dựa trên ordinal
compareTo cũng dựa trên ordinal. Dùng nó cho “mức độ” như needsPaging() ở mục 2.2 là chấp nhận được khi thứ tự khai báo chính là thứ tự nghiệp vụ. Hãy ghi chú điều đó trong code để người sau không sắp các hằng theo bảng chữ cái.
4. Switch trên enum và kiểm tra đủ trường hợp
Ý chính: switch expression trên enum không có default được compiler kiểm tra exhaustive (đủ mọi trường hợp): thiếu một hằng là không biên dịch. Thêm hằng mới thành danh sách việc do compiler đưa ra.
Switch expression có từ Java 14 (xem Java cơ bản):
static String label(Status s) {
return switch (s) {
case ACTIVE -> "Đang hoạt động";
case BLOCKED -> "Bị khoá";
}; // thêm Status.DELETED -> lỗi biên dịch ở đây, đúng điều ta muốn
}
Kiểm tra này chỉ đúng khi mọi chỗ dùng được biên dịch lại. Nếu enum nằm ở thư viện được nâng version mà code gọi không build lại, switch expression gặp hằng lạ ném MatchException (Java 21; trước đó là IncompatibleClassChangeError). Switch statement kiểu cũ thì lặng lẽ không vào nhánh nào.
null trong switch và cách viết nhãn case
- Switch trên biến enum đang
nullnémNullPointerException, kể cả khi códefault. Từ Java 21 viết đượccase null ->nếunulllà trường hợp hợp lệ. - Nhãn
casechỉ cần tên hằng (case ACTIVE), không cầnStatus.ACTIVE(từ Java 21 viết đầy đủ cũng được).
Khi mỗi trường hợp mang dữ liệu khác nhau: sealed interface và record
Enum hợp khi mọi giá trị có cùng hình dạng (cùng các field). Khi mỗi trường hợp mang dữ liệu khác (thẻ cần 4 số cuối, chuyển khoản cần IBAN, ví điện tử cần nhà cung cấp và số dư), một enum với đống field nullable là thiết kế tệ. Công cụ đúng là sealed interface (Java 17+, interface chỉ cho các class được liệt kê implement) cộng record, và pattern matching trong switch (Java 21), cũng được kiểm tra đủ trường hợp.
sealed interface Payment permits Card, BankTransfer, Wallet {}
record Card(String last4) implements Payment {}
record BankTransfer(String iban) implements Payment {}
record Wallet(String provider, BigDecimal balance) implements Payment {}
static String describe(Payment p) {
return switch (p) {
case Card c -> "card *" + c.last4();
case BankTransfer(String iban) -> "bank " + iban; // record pattern
case Wallet w when w.balance().signum() == 0 -> "empty wallet";
case Wallet w -> "wallet " + w.provider();
}; // không cần default: compiler biết chỉ có 3 kiểu
}
Bài tập
1. Nhập trạng thái đơn hàng an toàn
Đề (diễn giải): tạo enum trạng thái đơn hàng gồm chờ xác nhận, đang giao, đã giao, đã huỷ; mỗi trạng thái có mô tả tiếng Việt và một method cho biết đó có phải trạng thái cuối (đã giao hoặc đã huỷ) không. Đọc chuỗi người dùng nhập, in mô tả và cờ trạng thái cuối; nhập sai thì báo không hợp lệ thay vì crash.
Lời giải Bài 1: map tra cứu và chuẩn hoá đầu vào
Không dùng valueOf trực tiếp (nó ném exception và phân biệt hoa thường); dựng map tra cứu một lần và chuẩn hoá đầu vào.
import java.util.*;
public class OrderStatusDemo {
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; }
public String label() { return label; }
public boolean isFinal() {
return this == DELIVERED || this == CANCELLED;
}
private static final Map<String, OrderStatus> BY_NAME = new HashMap<>();
static {
for (OrderStatus s : values()) BY_NAME.put(s.name(), s);
}
public static Optional<OrderStatus> parse(String raw) {
if (raw == null) return Optional.empty();
return Optional.ofNullable(BY_NAME.get(raw.strip().toUpperCase(Locale.ROOT)));
}
}
public static void main(String[] args) {
for (String input : List.of("delivered", " SHIPPED ", "SHIPPING")) {
OrderStatus.parse(input).ifPresentOrElse(
s -> System.out.printf("%s -> %s, final=%b%n", input, s.label(), s.isFinal()),
() -> System.out.printf("%s -> invalid status%n", input));
}
}
}
// delivered -> Đã giao, final=true
// SHIPPED -> Đang giao hàng, final=false
// SHIPPING -> invalid status
Map được dựng trong khối static đặt sau các hằng, nên không dính lỗi “constructor dùng static field”.
2. Nâng cấp thành máy trạng thái
Đề: mở rộng bài 1 thành máy trạng thái thật: thêm trạng thái đã thanh toán và đã hoàn tiền, khai báo trạng thái nào được chuyển sang trạng thái nào, và chặn chuyển sai (ví dụ đã giao rồi thì không huỷ được).
Lời giải Bài 2: bảng chuyển trạng thái bằng EnumMap
Bảng chuyển trạng thái là EnumMap<OrderStatus, Set<OrderStatus>> dựng trong khối static (không truyền được EnumSet.of(SHIPPED) vào constructor của PENDING vì là forward reference). Khối static cũng kiểm tra mọi trạng thái đều đã khai báo, để thêm hằng mà quên thì app hỏng ngay lúc khởi động chứ không hỏng giữa một request.
enum OrderStatus {
PENDING, PAID, SHIPPED, DELIVERED, CANCELLED, REFUNDED;
private static final Map<OrderStatus, Set<OrderStatus>> NEXT = new EnumMap<>(OrderStatus.class);
static {
NEXT.put(PENDING, EnumSet.of(PAID, CANCELLED));
NEXT.put(PAID, EnumSet.of(SHIPPED, REFUNDED));
NEXT.put(SHIPPED, EnumSet.of(DELIVERED));
NEXT.put(DELIVERED, EnumSet.of(REFUNDED));
NEXT.put(CANCELLED, EnumSet.noneOf(OrderStatus.class));
NEXT.put(REFUNDED, EnumSet.noneOf(OrderStatus.class));
for (OrderStatus s : values()) {
if (!NEXT.containsKey(s)) throw new IllegalStateException("No transitions for " + s);
}
}
public boolean canMoveTo(OrderStatus target) { return NEXT.get(this).contains(target); }
public boolean isTerminal() { return NEXT.get(this).isEmpty(); }
}
final class Order {
private final String id;
private OrderStatus status = OrderStatus.PENDING;
Order(String id) { this.id = id; }
void moveTo(OrderStatus target) {
if (!status.canMoveTo(target)) {
throw new IllegalStateException(
"Order %s: %s -> %s is not allowed".formatted(id, status, target));
}
status = target;
}
}
Order o = new Order("A001");
o.moveTo(OrderStatus.PAID);
o.moveTo(OrderStatus.SHIPPED);
o.moveTo(OrderStatus.CANCELLED); // IllegalStateException: Order A001: SHIPPED -> CANCELLED is not allowed
Cách khác: method Set<OrderStatus> next() với switch expression trên this. Ưu điểm: compiler bắt thiếu hằng ngay lúc build; nhược điểm: tạo EnumSet mới mỗi lần gọi trừ khi cache. Trong hệ thống thật, chuyển trạng thái có điều kiện phụ (chỉ hoàn tiền trong 7 ngày) thuộc về service; enum chỉ giữ bảng chuyển hợp lệ.
Ghi nhớ
- Giải thích được vì sao enum an toàn hơn hằng
String/int, và khi nào tập giá trị nên nằm trong bảng DB. - Kể được compiler sinh gì cho một enum, và vì sao so bằng
==là đúng. - Biết vì sao constructor enum không dùng được static field, và dựng bảng tra ở đâu cho đúng.
- Parse được enum từ input người dùng mà không ném 500, không phụ thuộc locale.
- Biết khi nào bỏ
defaulttrong switch, và khi nào chuyển sang sealed interface + record.
Câu hỏi phỏng vấn
Junior
Vì sao nên dùng enum thay cho các hằng static final String?
Vì enum là một kiểu riêng: compiler chỉ cho truyền đúng các giá trị đã khai báo, còn với String thì chuỗi nào cũng biên dịch được.
Lỗi với String chỉ lộ ra lúc chạy. Enum còn so được bằng ==, dùng trong switch có kiểm tra đủ trường hợp, gắn được field và method cho từng giá trị, và có EnumSet/EnumMap hiệu năng cao.
Enum có constructor không? Vì sao không gọi new được?
Có, nhưng constructor luôn ngầm private: các instance duy nhất là các hằng được JVM tạo một lần khi load enum.
Enum có field, constructor và method như class. Không thể new, không thể tạo bằng reflection (Cannot reflectively create enum objects). Enum không kế thừa class khác được vì đã ngầm extends Enum, nhưng implement interface thì được.
So sánh hai giá trị enum bằng == hay equals?
Dùng ==: mỗi hằng là một instance duy nhất nên == đúng về ngữ nghĩa, nhanh và an toàn với null.
status == Status.ACTIVE không ném NPE khi status null. == còn được kiểm tra kiểu lúc biên dịch: so hai enum khác loại bằng == là lỗi biên dịch, còn equals thì lặng lẽ trả false.
Mid
Status.valueOf("active") với hằng tên ACTIVE cho kết quả gì? Bạn parse enum từ input người dùng thế nào?
Ném IllegalArgumentException, vì valueOf khớp chính xác name() và phân biệt hoa thường; null thì ném NullPointerException.
Với input bên ngoài: dựng sẵn một Map<String, Status> (hoặc theo mã riêng), chuẩn hoá bằng strip() và toUpperCase(Locale.ROOT), trả Optional. Ở tầng web, map giá trị không hợp lệ sang 400 chứ không để thành 500.
Switch expression trên enum không có default. Thêm một hằng mới vào enum thì chuyện gì xảy ra?
Nếu code dùng được biên dịch lại: lỗi biên dịch, và đó là điều tốt. Nếu không build lại: lúc chạy ném MatchException.
- Biên dịch lại: “the switch expression does not cover all possible input values”; compiler chỉ ra mọi chỗ cần xử lý.
- Enum ở thư viện được nâng version mà code gọi không build lại: gặp hằng mới, switch expression ném
MatchException(Java 21; trước đóIncompatibleClassChangeError). - Thêm
defaulttắt kiểm tra này, nên chỉ thêm khi enum do bên ngoài sở hữu, và làm nhánhdefaultbáo lỗi rõ ràng.
Senior
Khi nào bạn chọn sealed interface cộng record thay vì enum?
Khi các trường hợp mang dữ liệu khác nhau; nếu chỉ là danh sách giá trị cố định cùng hình dạng thì vẫn dùng enum.
Ví dụ thẻ cần 4 số cuối, chuyển khoản cần số tài khoản, ví điện tử cần nhà cung cấp. Enum buộc mọi hằng cùng field và là singleton, nên thành đống field nullable. Sealed interface + record cho mỗi trường hợp một kiểu với dữ liệu riêng, nhiều instance, và switch pattern matching vẫn kiểm tra đủ trường hợp. Đổi lại mất values(), EnumSet/EnumMap, và lưu DB hay JSON phải thiết kế discriminator.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| enumeration | /ɪˌnuːməˈreɪʃn/ | kiểu liệt kê | “An enumeration gives us a closed set of values checked at compile time.” |
| constant-specific body | /ˈkɑːnstənt spəˈsɪfɪk/ | thân riêng của từng hằng | “Each constant has a constant-specific body that overrides the abstract method.” |
| ordinal | /ˈɔːrdənl/ | số thứ tự khai báo | “I never persist the ordinal, because reordering the constants would corrupt the data.” |
| exhaustive | /ɪɡˈzɔːstɪv/ | đầy đủ mọi trường hợp | “The switch expression is exhaustive, so the compiler flags every place to update.” |
| sealed interface | /siːld ˈɪntərfeɪs/ | interface giới hạn implementation | “When each case carries different data, I use a sealed interface with records.” |
| type safety | /taɪp ˈseɪfti/ | an toàn kiểu | “Enums give us type safety that String constants can’t.” |
| lookup table | /ˈlʊkʌp ˈteɪbl/ | bảng tra cứu | “I build a lookup table once in a static block instead of looping over values().” |
| state machine | /steɪt məˈʃiːn/ | máy trạng thái | “The order status enum doubles as a small state machine with allowed transitions.” |
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.