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

Tìm kiếm

Java CoreJunior14 phút đọc

Generics trong Java: generic class, generic method, bounded type và invariance

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

Cụm bài Generics trong Java: 1. Generic class, method, bounded type · 2. Wildcard và PECS · 3. Type erasure và type token

Trước Java 5, collection chỉ chứa Object: nhét nhầm kiểu vẫn compile, rồi nổ ClassCastException lúc chạy ở một chỗ xa chỗ gây lỗi. Generics đưa kiểu vào chữ ký class và method để compiler bắt lỗi đó lúc biên dịch. Đọc xong, bạn viết được generic class, generic method, bounded type và giải thích được vì sao List<Integer> không phải List<Number>.

Chỉ cần biết OOP và Collections cơ bản. Phần 2 là wildcard và quy tắc PECS, phần 3 là type erasure và cách Jackson lấy lại kiểu lúc runtime.

Sơ đồ tóm tắt:

flowchart TD
  G[Generics] --> CT["Lỗi kiểu: lúc compile"]
  G --> GC["Generic class: theo object"]
  G --> GM["Generic method: theo lần gọi"]
  GM --> SM["Static method: tự khai báo T"]
  G --> B["Bound: T extends X"]
  G --> INV["Invariant: List#lt;Integer#gt; ≠ List#lt;Number#gt;"]
  INV -.->|khác| ARR["Mảng covariant: ArrayStoreException"]
  V["var + new ArrayList#lt;#gt;()"] -.->|bẫy| OB["ArrayList#lt;Object#gt;"]

1. Vì sao cần generics

Ý chính: không có generics, lỗi nhét nhầm kiểu chỉ lộ ra lúc chạy. Có generics, compiler chặn ngay khi gõ code và tự chèn cast.

Code kiểu cũ dùng raw type (kiểu generic viết không có <>, coi như chứa Object):

List names = new ArrayList();
names.add("Alice");
names.add(42);                     // compiler không phản đối

for (Object o : names) {
    String s = (String) o;         // ClassCastException ở phần tử thứ hai
    System.out.println(s.toUpperCase());
}

Với generics:

List<String> names = new ArrayList<>();
names.add("Alice");
// names.add(42);                  // lỗi compile: int không phải String
String first = names.get(0);       // không cần cast

Generics mang lại ba thứ:

  1. Phát hiện lỗi sớm: lỗi kiểu chuyển từ runtime (lúc khách hàng đang dùng) sang compile time (lúc bạn đang gõ code).
  2. Bỏ cast thủ công: compiler tự chèn cast, và cast đó không bao giờ thất bại nếu code không có cảnh báo unchecked.
  3. Tái sử dụng có kiểm soát: một Box<T>, một Repository<T, ID>, một sort cho mọi kiểu so sánh được, thay vì copy code hoặc dùng Object mất kiểu.

Điểm 2 đáng nhớ: generics không làm code nhanh hơn hay “an toàn hơn” ở bytecode. Cast vẫn có, chỉ là do compiler sinh ra (xem phần 3 về type erasure).

2. Generic class và generic method

Ý chính: đặt type parameter ở class khi kiểu là trạng thái của object; đặt ở method khi kiểu chỉ liên quan tới một lần gọi.

2.1. Generic class

Type parameter khai báo sau tên class, dùng như một kiểu bình thường bên trong:

public final class Box<T> {
    private T value;

    public Box(T value) { this.value = value; }

    public T get() { return value; }
    public void set(T value) { this.value = value; }

    // generic method bên trong generic class: có thêm type parameter R riêng
    public <R> Box<R> map(Function<? super T, ? extends R> mapper) {
        return new Box<>(mapper.apply(value));
    }
}

Box<String> name = new Box<>("hello");
Box<Integer> length = name.map(String::length);   // Box[5]

Bốn thuật ngữ cần phân biệt:

  • T trong class Box<T> là type parameter (tham số kiểu).
  • String trong Box<String> là type argument (đối số kiểu).
  • Box<String> là parameterized type; Box (không có <>) là raw type.
  • new Box<>(...) dùng diamond operator (Java 7): compiler tự suy ra type argument từ vế trái.

Nhiều type parameter thì phân tách bằng dấu phẩy: Map<K, V>, Pair<A, B>.

2.2. Generic method

Generic method tự khai báo type parameter, đặt trước kiểu trả về. Class chứa nó có generic hay không cũng được:

public final class Lists {
    private Lists() {}

    public static <T> T firstOrNull(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }
}

String s = Lists.firstOrNull(List.of("a", "b"));        // T được suy ra là String
String t = Lists.<String>firstOrNull(List.of("x"));     // chỉ định tường minh (type witness)

Compiler thường tự suy ra T (type inference — suy luận kiểu) từ đối số và từ kiểu mà kết quả được gán vào. Type witness Lists.<String>firstOrNull(...) hiếm khi cần, chủ yếu khi inference bị nhập nhằng.

Ví dụ printArray và vì sao nó không nhận mảng primitive

Ví dụ hay gặp trong tài liệu nhập môn: in mọi phần tử của một mảng bất kỳ kiểu nào.

public static <T> void printArray(T[] arr) {
    for (T e : arr) System.out.print(e + " ");
    System.out.println();
}

printArray(new String[] {"Alice", "Bob"});   // Alice Bob
printArray(new Integer[] {1, 2, 3});         // 1 2 3

2.3. Quy ước đặt tên

Tên type parameter là một chữ cái in hoa, để không nhầm với tên class thật: T (Type), E (Element), K/V (Key/Value), R (Result). Tên dài hơn được khi có nghĩa nghiệp vụ rõ (ID trong JpaRepository<T, ID>), miễn đừng trùng class có thật.

Bảng quy ước đầy đủ với ví dụ trong JDK
Ký hiệu Ý nghĩa thường gặp Ví dụ trong JDK
T Type Optional<T>, Supplier<T>
E Element List<E>, Set<E>
K, V Key, Value Map<K, V>
R Result (kiểu trả về) Function<T, R>
N Number ít dùng
S, U kiểu thứ 2, thứ 3 BiFunction<T, U, R>

Bẫy hay gặp: diamond suy ra type argument từ vế trái. Với var list = new ArrayList<>(); vế trái không có kiểu, nên ra ArrayList<Object>, và list.add(1); list.add("oops"); đều compile. Khi dùng var, ghi kiểu ở vế phải: var list = new ArrayList<String>();.

3. Bounded type parameter

Ý chính: T trơn chỉ gọi được method của Object. Thêm bound <T extends X> thì T phải là con của X, đổi lại được gọi method của X.

// T phải là Number hoặc lớp con -> được gọi doubleValue()
static <T extends Number> double sumOf(List<T> values) {
    double total = 0;
    for (T v : values) total += v.doubleValue();
    return total;
}
  • Từ khoá luôn là extends, kể cả khi bound là interface (<T extends Comparable<T>>).
  • Multiple bounds dùng &, tối đa một class và class đứng đầu: <T extends Number & Comparable<T>>.
  • Recursive bound: bound nhắc lại chính T, như Enum<E extends Enum<E>> hay các hàm cần so sánh.

Hàm max đúng chuẩn dùng <T extends Comparable<? super T>>, không phải Comparable<T>, để nhận cả kiểu kế thừa compareTo từ lớp cha.

Hàm max đầy đủ và vì sao Comparable<T> từ chối LocalDate

Chữ ký giống Collections.max:

static <T extends Comparable<? super T>> T max(Collection<? extends T> items) {
    Iterator<? extends T> it = items.iterator();
    T best = it.next();                      // ném NoSuchElementException nếu rỗng
    while (it.hasNext()) {
        T candidate = it.next();
        if (candidate.compareTo(best) > 0) best = candidate;
    }
    return best;
}

4. Invariance: vì sao List<Integer> không phải List<Number>

Ý chính: nếu List<Integer> là List<Number> thì nhét được Double vào list số nguyên. Vì vậy generics invariant (không kế thừa theo type argument), còn mảng covariant và trả giá bằng kiểm tra lúc chạy.

List<Integer> ints = new ArrayList<>(List.of(1, 2));
// List<Number> nums = ints;    // lỗi compile: incompatible types
nums.add(3.14);                 // giả sử dòng trên được phép: Double là Number, hợp lệ
Integer x = ints.get(2);        // nhưng ints và nums là cùng một list -> nổ

List<A> và List<B> không có quan hệ cha con, bất kể A và B ra sao. Muốn có quan hệ thì dùng wildcard, chủ đề của phần 2.

Mảng thì ngược lại: Integer[] là con của Number[]. Đây là quyết định từ Java 1.0, trước khi có generics, để viết được hàm như Arrays.sort(Object[]). Cái giá: mảng mang kiểu phần tử lúc runtime, JVM kiểm tra mỗi lần ghi và ném ArrayStoreException nếu sai.

Mảng T[] Generics List<T>
Quan hệ cha con Covariant: Integer[] là con của Number[] Invariant: List<Integer> không liên quan List<Number>
Thông tin kiểu lúc chạy Có (reified) Không (bị erase)
Ghi sai kiểu bị phát hiện khi Runtime (ArrayStoreException) Compile time
Kiểu phần tử primitive Được (int[]) Không (List<Integer>)

Bài tập

Bài 1: Giao dịch generic

Đề (diễn đạt lại): viết class generic với ba type parameter cho mã giao dịch, số tiền và trạng thái. Mã là số hoặc chuỗi, số tiền là số nguyên hoặc số thực, trạng thái là chuỗi hoặc enum; tạo vài object và in ra.

Lời giải Bài 1: record generic có bound và nhận xét review

Dùng record cho gọn, thêm bound AMOUNT extends Number để không ai truyền nhầm String làm số tiền, và kiểm tra null trong compact constructor.

enum TxStatus { PENDING, SUCCESS, FAILED }

record Transaction<ID, AMOUNT extends Number, STATUS>(ID id, AMOUNT amount, STATUS status) {
    Transaction {
        Objects.requireNonNull(id, "id");
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(status, "status");
    }
}

var t1 = new Transaction<>(1001L, new BigDecimal("250000.50"), TxStatus.SUCCESS);
var t2 = new Transaction<>("TX-ABC", 99, "FAILED");
System.out.println(t1);   // Transaction[id=1001, amount=250000.50, status=SUCCESS]

Nhận xét khi review: ba type parameter là quá nhiều cho một model nghiệp vụ thật. Tiền nên luôn là BigDecimal (không dùng double), trạng thái nên luôn là enum. Generics hợp với cấu trúc dữ liệu và hạ tầng (container, repository, cache); model nghiệp vụ nên có kiểu cụ thể. Bound AMOUNT extends Number ít nhất chặn được lỗi rõ ràng nhất.

Ghi nhớ

  • Giải thích được vì sao generics đưa lỗi kiểu về compile time mà bytecode vẫn có cast.
  • Biết khi nào đặt type parameter ở class, khi nào ở method, và vì sao static method phải tự khai báo <T>.
  • Viết được bound nhiều lớp với & và giải thích vì sao max dùng Comparable<? super T>.
  • Giải thích được vì sao List<Integer> không phải List<Number> còn Integer[] là Number[].
  • Biết bẫy var cộng diamond và cách tránh.

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

Junior

Generics giải quyết vấn đề gì?

Đưa lỗi kiểu từ runtime về compile time.

Không nhét nhầm kiểu vào collection được, không cần cast thủ công khi lấy ra (compiler tự chèn cast và đảm bảo nó đúng), và viết được class/method tái sử dụng cho nhiều kiểu mà vẫn type-safe.

Generic class và generic method khác nhau thế nào?

Generic class gắn kiểu với từng object; generic method gắn kiểu với từng lần gọi.

Generic class khai báo type parameter sau tên class (class Box<T>), mọi method instance dùng chung T đó. Generic method khai báo trước kiểu trả về (static <T> T first(List<T>)), T thường được suy ra từ đối số. Static method không dùng được type parameter của class, nên phải là generic method.

Diamond operator là gì? Dùng chung với var có bẫy gì?

new ArrayList<>() để compiler tự suy ra type argument; với var thì không có gì để suy, nên ra ArrayList<Object>.

Diamond (Java 7) suy kiểu từ vế trái hoặc từ ngữ cảnh, đỡ phải viết lại <String>. Với var list = new ArrayList<>();, mọi thứ add vào đều compile. Khi dùng var, ghi type argument ở vế phải: var list = new ArrayList<String>();.

Mid

Vì sao List<Integer> không phải là List<Number> trong khi Integer[] là Number[]?

Generics invariant để compiler chặn được việc add(3.14) vào một List<Integer>; mảng covariant từ Java 1.0 và bù lại bằng kiểm tra lúc chạy.

Mảng biết kiểu phần tử của nó, nên JVM kiểm tra mỗi lần ghi và ném ArrayStoreException. Generics bị erase nên không kiểm tra được lúc chạy, do đó phải chặn từ compile time.

Khi nào đặt type parameter ở class, khi nào ở method?

Ở class khi kiểu là trạng thái của object; ở method khi kiểu chỉ liên quan một lần gọi.

Ở class khi nhiều method phải nhất quán với nhau (Cache<K, V>, Repository<T, ID>); mỗi instance gắn với một bộ type argument. Ở method đặc biệt cho method static, vì static không thấy type parameter của class. Dấu hiệu đặt sai: class có <T> mà chỉ một method dùng, hoặc phải tạo Util<String> chỉ để gọi một hàm tiện ích.

Vì sao <T> void printArray(T[] arr) không nhận int[]? API nên nhận mảng hay List<T>?

T chỉ là kiểu tham chiếu, nên int[] không phải T[] với bất kỳ T nào. API nghiệp vụ nên ưu tiên List<T>.

Autoboxing không áp dụng cho cả mảng, nên mảng primitive cần overload riêng. List<T> type-safe lúc compile, có bản immutable, không có lỗi covariant ArrayStoreException. Mảng hợp với dữ liệu số lớn và code nóng về hiệu năng (int[] gọn hơn List<Integer> nhiều) hoặc varargs.

Senior

Vì sao Collections.max có chữ ký <T extends Object & Comparable<? super T>> T max(Collection<? extends T>)?

Comparable<? super T> để nhận kiểu kế thừa compareTo từ cha, ? extends T vì collection là producer, còn Object & là mẹo tương thích nhị phân.

Ví dụ LocalDate implement Comparable<ChronoLocalDate>. Erasure lấy bound đầu tiên, nên kiểu trả về sau erase là Object như bản max trước Java 5, thay vì Comparable, giúp code đã compile với API cũ không bị vỡ.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu trong phỏng vấn
type parameter /taɪp pəˈræmɪtər/ tham số kiểu (T) “The type parameter is declared before the return type in a generic method.”
type argument /taɪp ˈɑːrɡjumənt/ đối số kiểu (String trong List<String>) “The compiler infers the type argument from the target type.”
type safety /taɪp ˈseɪfti/ an toàn kiểu “Generics move type safety checks from runtime to compile time.”
bounded type /ˈbaʊndɪd taɪp/ kiểu có giới hạn “I use a bounded type so the method can call compareTo.”
invariant /ɪnˈvɛəriənt/ bất biến (không kế thừa theo type argument) “Generics are invariant, so a list of integers isn’t a list of numbers.”
covariant /koʊˈvɛəriənt/ hiệp biến “Arrays are covariant, which is why ArrayStoreException exists.”
type inference /taɪp ˈɪnfərəns/ suy luận kiểu “Type inference figures out T from the arguments, so I rarely need a type witness.”
diamond operator /ˈdaɪmənd ˈɑːpəreɪtər/ toán tử <> “With the diamond operator the compiler infers the type argument from the left-hand side.”

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.