Generics trong Java: lớp và phương thức an toàn kiểu

Vì sao có generics

Kiểu generic cho phép bạn viết code một lần và dùng lại cho nhiều kiểu mà không đánh mất an toàn kiểu. Thay vì viết riêng IntBox, StringBox và UserBox, bạn viết một Box<T> duy nhất, trong đó T là chỗ trống để nơi gọi điền vào.

Bạn đã dùng generics mỗi lần viết ArrayList<String> hoặc một HashMap như HashMap<String, Integer>. Phần <...> là đối số kiểu (type argument). Trang này chỉ bạn cách tự viết kiểu generic.

Cách làm thay thế, lưu mọi thứ dưới dạng Object, sẽ vứt bỏ thông tin kiểu và buộc bạn ép kiểu một cách xấu xí, dễ sai:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // nothing stops this mistake

        String first = (String) raw.get(0); // every read needs a cast
        String oops = (String) raw.get(1);  // compiles, then crashes at runtime
        System.out.println(first + " " + oops);
    }
}

Lệnh ép kiểu ở dòng cuối ném ClassCastException lúc chạy, đúng loại ngoại lệ mà generics được thiết kế để loại bỏ.

Lớp generic

Khai báo tham số kiểu trong dấu ngoặc nhọn ngay sau tên lớp. Theo quy ước, đó là một chữ cái in hoa: T cho "type", E cho "element", K/V cho key/value.

class Box<T> {
    private T value;

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

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

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // no cast - the compiler knows it's a String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // won't compile - Box<String> only accepts Strings
    }
}

Bên trong Box, mọi T trở thành kiểu mà nơi gọi cung cấp. Box<String> là một chiếc hộp chỉ chứa và trả về String. Trình biên dịch từ chối name.set(99) trước khi chương trình kịp chạy.

Cặp <> rỗng ở vế phải (toán tử kim cương, diamond operator) cho phép trình biên dịch suy ra đối số kiểu từ vế trái, nên bạn không phải viết <String> hai lần.

Phương thức generic

Một phương thức có thể có tham số kiểu riêng, độc lập với lớp. Đặt tham số <T> trước kiểu trả về:

import java.util.List;

public class Main {

    // <T> declares the type parameter; T is the element type
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T inferred as String
        Integer n = firstOrNull(nums);   // T inferred as Integer
        System.out.println(w + " " + n);
    }
}

Bạn không bao giờ truyền T một cách tường minh: trình biên dịch tự suy ra từ đối số. Phương thức generic là cách các tiện ích như Collections.sort hay List.of giữ được an toàn kiểu với mọi kiểu phần tử.

Tham số kiểu có giới hạn

Đôi khi một kiểu generic chỉ có nghĩa với một số kiểu. extends ràng buộc tham số để bạn gọi được phương thức của kiểu giới hạn. Ở đây T extends Number nghĩa là T là Number hoặc bất kỳ lớp con nào (Integer, Double, ...), nên dùng được doubleValue():

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // legal because T is at least a Number
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Lưu ý extends ở đây nghĩa là "là kiểu con của", và nó dùng được cho cả lớp lẫn interface: <T extends Comparable<T>> cực kỳ phổ biến khi bạn cần so sánh các phần tử.

Wildcard: ? extends và ? super

Một cái bẫy tinh vi: List<Integer> không phải là List<Number>, dù Integer là Number. Generics là bất biến (invariant). Wildcard nới lỏng điều này khi bạn chỉ cần đọc hoặc chỉ cần ghi.

Dùng ? extends T cho nguồn cung cấp dữ liệu mà bạn đọc ra, và ? super T cho nơi tiêu thụ mà bạn ghi vào (quy tắc "PECS", Producer Extends, Consumer Super):

import java.util.ArrayList;
import java.util.List;

public class Main {

    // reads Numbers out - accepts List<Integer>, List<Double>, etc.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // writes Integers in - accepts List<Integer>, List<Number>, List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // works thanks to ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // works thanks to ? super
        System.out.println(bucket);
    }
}

List ? extends Number cho phép bạn đọc phần tử dưới dạng Number nhưng không cho thêm vào (trình biên dịch không biết chính xác kiểu phần tử). List ? super Integer cho phép thêm Integer nhưng khi đọc thì nhận về Object. Hãy chọn wildcard khớp với hướng đi của dữ liệu.

Type erasure và giới hạn của nó

Generics là tính năng lúc biên dịch. Sau khi biên dịch, tham số kiểu bị xóa (erased): lúc chạy, Box<String> và Box<Integer> đều chỉ là Box. Điều này giúp generics tương thích ngược với code cũ, nhưng cũng đặt ra những giới hạn thật sự.

// None of these compile - the type parameter doesn't exist at runtime:
T value = new T();          // can't instantiate a type parameter
T[] array = new T[10];      // can't create a generic array
if (list instanceof List<String>) { } // can't test the type argument

Vì kiểu đã biến mất lúc chạy, bạn không thể hỏi "T là gì?" qua reflection, và không thể nạp chồng các phương thức chỉ khác nhau ở đối số generic (foo(List<String>) và foo(List<Integer>) bị xóa về cùng một chữ ký). Khi thực sự cần kiểu lúc chạy, hãy truyền một token Class<T> làm tham số của constructor hoặc phương thức.

Tiếp theo: biểu thức lambda

Bạn đã thấy phương thức generic nhận một kiểu làm tham số. Bước tiếp theo là coi hành vi như một tham số. Biểu thức lambda cho phép bạn truyền một đoạn code, tức một hàm, vào phương thức, và đó chính là cách bạn sẽ sắp xếp, lọc và biến đổi các collection generic mà bạn vừa học cách định kiểu an toàn.