Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
JavaĐọc trong 19 phútMã đã được kiểm chứng

Generic: <T> trong phương thức và lớp generic

Generic cho phép bạn viết một phương thức hoặc lớp chạy được với nhiều kiểu, trong khi trình biên dịch vẫn kiểm tra từng kiểu. Bài hướng dẫn này nói về ý nghĩa của <T>, phương thức generic, generic có giới hạn với extends, lớp generic, và vài việc generic không cho phép bạn làm. Mọi đoạn mã đều đã được biên dịch và chạy trên OpenJDK 21.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Java

Quầy đồ thất lạc với những chiếc thùng có nhãn#

Hãy hình dung quầy đồ thất lạc ở một bến xe buýt đông đúc. Sau quầy là cả bức tường những chiếc thùng nhựa giống hệt nhau, mỗi thùng có một ô nhãn để trống. Nhân viên viết “Khăn quàng” lên một thùng và “Chìa khóa” lên thùng khác. Từ đó, mỗi thùng chỉ đựng đúng loại đồ ấy. (Quầy đồ thất lạc nào trên đời cũng có một thùng chủ yếu toàn ô.)

Generic trong Java hoạt động theo cách đó. Bạn viết một phương thức hoặc lớp một lần, với một chỗ trống cho kiểu, và người dùng sẽ điền vào chỗ trống ấy. Chỗ trống đó là một tham số kiểu (type parameter), thường là một chữ cái viết hoa trong dấu ngoặc nhọn: <T>. Kiểu thật điền vào, chẳng hạn String, là đối số kiểu (type argument). Nó đứng thay cho một kiểu giống như tham số đứng thay cho một giá trị.

Bạn đã làm điều này rồi: ArrayList<String> điền vào chỗ trống của lớp thư viện ArrayList<E>, và trình biên dịch đọc nhãn đó. Bài hướng dẫn này xây một chương trình duy nhất, LostAndFound, cho quầy đồ thất lạc, bắt đầu bằng sổ ghi mô tả các món đồ:

LostAndFound.java
import java.util.ArrayList;

public class LostAndFound {
    public static void main(String[] args) {
        ArrayList<String> log = new ArrayList<>();
        log.add("black umbrella");
        log.add(42);
    }
}
LostAndFound.java:7: error: incompatible types: int cannot be converted to String
        log.add(42);
                ^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

Danh sách được gắn nhãn String, nên số 42 bị từ chối trước khi chương trình kịp chạy. Đó chính là mục đích của generic: viết mã một lần, và để trình biên dịch kiểm tra mọi kiểu đi vào và đi ra.

Một phương thức cho mỗi kiểu, hay cứ dùng Object?#

Hãy bắt đầu từ một dạng bạn đã biết. Quầy giữ một kệ tên các món đồ, và bạn muốn một phương thức in cả kệ trên một dòng:

LostAndFound.java
public class LostAndFound {
    public static void printShelf(String[] shelf) {
        String line = "Shelf:";
        for (String item : shelf) {
            line += " " + item;
        }
        System.out.println(line);
    }

    public static void main(String[] args) {
        String[] items = {"umbrella", "scarf", "keys"};
        printShelf(items);
    }
}
Shelf: umbrella scarf keys

Giờ quầy thêm một kệ số thẻ, là một Integer[]. Chép phương thức và thay String bằng Integer thì chạy được, nhưng mỗi lần sửa lỗi lại phải sửa hai nơi.

Có một lối tắt hiển nhiên. Mọi lớp đều là một loại Object, và Java cho phép một mảng String đặt vào chỗ cần Object[]. Vậy một phương thức nhận Object[] sẽ chấp nhận mọi kệ. Đây là ý tưởng đó trong một phương thức trả về món đầu tiên trên kệ.

Hãy thử trước

firstItem trả về một Object, nên người gọi phải ép kiểu (cast) nó, nghĩa là bảo Java “hãy coi giá trị này là một String”. Hãy nhìn dòng ép thẻ đầu tiên sang String. Nó có biên dịch được không? Nếu có, điều gì xảy ra khi chạy?

Xem đáp án

Nó biên dịch được. Trình biên dịch chỉ biết kết quả là một Object nào đó, có thể là một String, nên nó tin phép ép kiểu của bạn. Lúc chạy, giá trị là một Integer, và phép ép kiểu thất bại với ClassCastException.

LostAndFound.java
public class LostAndFound {
    public static Object firstItem(Object[] shelf) {
        return shelf[0];
    }

    public static void main(String[] args) {
        String[] items = {"umbrella", "scarf", "keys"};
        Integer[] tags = {104, 101, 103};
        String first = (String) firstItem(items);    // cast needed
        System.out.println("First item: " + first);
        String wrong = (String) firstItem(tags);     // compiles, then fails
        System.out.println("Never printed: " + wrong);
    }
}
First item: umbrella
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
	at LostAndFound.main(LostAndFound.java:11)

Phương thức đã vứt bỏ nhãn, nên kết quả nào cũng cần ép kiểu, và một phép ép kiểu sai chỉ bị phát hiện lúc chạy. Các lớp collection của Java hoạt động như vậy trước Java 5. (Danh sách Python cũng chứa được mọi thứ, và bạn chỉ biết bên trong có gì khi dùng đến. Java muốn có nhãn ngay từ đầu.)

Một thay đổi duy nhất: tham số kiểu#

Quay lại phiên bản dùng String. Một phương thức generic là chính phương thức đó với một thay đổi: khai báo một tham số kiểu, <T>, rồi viết T ở mọi chỗ bạn đã viết String.

Phần khai báo nằm ở một vị trí chính xác: sau các từ bổ nghĩa (public static) và ngay trước kiểu trả về. Hãy đọc public static <T> T firstItem(T[] shelf) là “với mọi kiểu T, trả về một T từ một mảng T”. Chữ T đầu tiên khai báo tham số kiểu. Mọi chữ T về sau đều dùng nó.

LostAndFound.java
public class LostAndFound {
    public static <T> void printShelf(T[] shelf) {
        String line = "Shelf:";
        for (T item : shelf) {
            line += " " + item;
        }
        System.out.println(line);
    }

    public static <T> T firstItem(T[] shelf) {
        return shelf[0];
    }

    public static <T> void swap(T[] shelf, int i, int j) {
        T temp = shelf[i];
        shelf[i] = shelf[j];
        shelf[j] = temp;
    }

    public static void main(String[] args) {
        String[] items = {"umbrella", "scarf", "keys"};
        Integer[] tags = {104, 101, 103};
        printShelf(items);
        printShelf(tags);
        String first = firstItem(items);             // no cast
        int firstTag = firstItem(tags);
        System.out.println(first + " has tag " + firstTag);
        swap(items, 0, 2);
        printShelf(items);
    }
}
Shelf: umbrella scarf keys
Shelf: 104 101 103
umbrella has tag 104
Shelf: keys scarf umbrella

Một printShelf in được cả hai kệ, và hai lần gọi firstItem đều không cần ép kiểu. Integer được unbox, nghĩa là tự động chuyển thành một int thuần. swap chạy trên mọi kệ; chỉ số 2 là món thứ ba, vì chỉ số bắt đầu từ 0.

Bây giờ là lỗi đã làm phiên bản Object sập:

LostAndFound.java
public class LostAndFound {
    public static <T> T firstItem(T[] shelf) {
        return shelf[0];
    }

    public static void main(String[] args) {
        Integer[] tags = {104, 101, 103};
        String wrong = firstItem(tags);
        System.out.println("Never printed: " + wrong);
    }
}
LostAndFound.java:8: error: incompatible types: inference variable T has incompatible bounds
        String wrong = firstItem(tags);
                                ^
    upper bounds: String,Object
    lower bounds: Integer
  where T is a type-variable:
    T extends Object declared in method <T>firstItem(T[])
1 error

Lỗi sập lúc chạy giờ trở thành lỗi biên dịch, sẽ đọc ở phần kế tiếp.

Kiểm tra bẫy: <T> đặt ở đâu?

Với một phương thức generic, <T> luôn đặt trước kiểu trả về. Nếu bỏ nó đi, như public static T firstItem(T[] shelf), Java sẽ cho rằng T là một lớp bạn quên viết. Bạn nhận được cannot find symbol với symbol: class T, mỗi chữ T trong dòng khai báo một lần. Thông báo đó có nghĩa là: hãy tìm một <T> bị thiếu.

Java điền T như thế nào: suy luận kiểu#

Bạn chưa bao giờ viết <String> khi gọi printShelf. Java tự tìm ra T phải là gì, việc này gọi là suy luận kiểu (type inference). Nó thu thập các quy tắc mà T phải tuân theo, gọi là giới hạn (bounds) trong các thông báo, rồi tìm một kiểu tuân theo tất cả.

Trong lỗi vừa rồi, đối số tags khiến Integer trở thành một giới hạn dưới: T phải là Integer hoặc một kiểu ở trên nó. Biến nhận kết quả, gọi là kiểu đích (target type), khiến String trở thành một giới hạn trên: T phải là String hoặc ở dưới nó. (Object được liệt kê vì nó là giới hạn của mọi T thông thường.) Không có kiểu nào vừa là “Integer hoặc cao hơn” vừa là “String hoặc thấp hơn”, nên kết quả là incompatible bounds.

Bạn cũng có thể tự nêu kiểu bằng một đối số kiểu tường minh. Nó đặt sau dấu chấm và ngay trước tên phương thức: LostAndFound.<Integer>firstItem(tags). Với phương thức static, tên lớp và dấu chấm là bắt buộc. Hãy nhận ra dạng này trong bài thi.

Suy luận còn thú vị hơn khi hai đối số dùng chung một T:

LostAndFound.java
public class LostAndFound {
    public static <T> T firstItem(T[] shelf) {
        return shelf[0];
    }

    public static <T> T choose(boolean takeFirst, T a, T b) {
        if (takeFirst) {
            return a;
        }
        return b;
    }

    public static void main(String[] args) {
        Integer[] tags = {104, 101, 103};
        Integer tag = LostAndFound.<Integer>firstItem(tags);  // T named by hand
        String item = choose(false, "scarf", "keys");        // T is String
        Object either = choose(true, "scarf", 104);          // String and Integer
        System.out.println(tag + " " + item + " " + either);
    }
}
104 keys scarf
Hãy thử trước

Trong choose(true, "scarf", 104), takeFirst là true, nên giá trị trả về là String "scarf". Liệu String item = choose(true, "scarf", 104); có biên dịch được không?

Xem đáp án

Không. Suy luận diễn ra lúc biên dịch và chỉ xét các kiểu, không bao giờ xét true hay false. T phải chấp nhận cả một String và một Integer, nên nó không bao giờ có thể là String. javac báo inferred type does not conform to upper bound(s). Biến Object trong đoạn mã nhận được kết quả, đó là lý do dòng ấy biên dịch được.

Phương thức generic có giới hạn: T extends một kiểu nào đó#

Quầy muốn tìm món lớn nhất trên một kệ: thẻ mới nhất, hoặc tên cuối cùng theo thứ tự bảng chữ cái. Java so sánh các đối tượng bằng compareTo.

Hãy thử trước

Viết largest với một <T> thông thường và gọi shelf[i].compareTo(best) bên trong. Nó có biên dịch được không?

Xem đáp án

Không. Một T thông thường có thể là kiểu bất kỳ, nên Java chỉ cho phép những gì mọi đối tượng đều có: các phương thức của Object. javac báo cannot find symbol cho compareTo, kèm location: class Object.

Cách sửa là một giới hạn (bound), còn gọi là giới hạn trên. Nó hạn chế những kiểu được điền vào chỗ trống, và đổi lại cho phép bạn gọi các phương thức của chúng. Viết <T extends Comparable<T>>: “mọi kiểu T có thể so sánh với các T khác”. Bản thân Comparable cũng là generic, được khai báo là Comparable<T>, đó là lý do T xuất hiện hai lần. Đây là một tham số kiểu có giới hạn. Một lớp implements Comparable, nhưng giới hạn luôn dùng extends, cho cả lớp lẫn giao diện.

Một giới hạn phổ biến thứ hai là <T extends Number>. Number là lớp cha của Integer, Double và các lớp bao khác (các phiên bản lớp của kiểu số nguyên thủy). Nó cho tất cả các lớp đó phương thức doubleValue().

Hãy thử trước

Hãy dự đoán cả bốn dòng. Tiền mặt là 20, 5 và 40 đô la; cân nặng là 0.5, 1.25 và 0.25 kilôgam. Hãy chú ý kiểu trả về của total.

Xem đáp ánNewest tag: 104, Last by name: umbrella, Cash found: 65.0 và Total weight: 2.0. Tiền mặt in ra 65.0 vì total trả về một double.
LostAndFound.java
public class LostAndFound {
    public static <T extends Comparable<T>> T largest(T[] shelf) {
        T best = shelf[0];                           // assume the first is largest
        for (int i = 1; i < shelf.length; i++) {
            if (shelf[i].compareTo(best) > 0) {
                best = shelf[i];
            }
        }
        return best;
    }

    public static <T extends Number> double total(T[] values) {
        double sum = 0;
        for (T v : values) {
            sum += v.doubleValue();                  // every Number has this
        }
        return sum;
    }

    public static void main(String[] args) {
        Integer[] tags = {104, 101, 103};
        String[] items = {"umbrella", "scarf", "keys"};
        System.out.println("Newest tag: " + largest(tags));
        System.out.println("Last by name: " + largest(items));

        Integer[] cash = {20, 5, 40};                // dollars found in wallets
        Double[] weights = {0.5, 1.25, 0.25};        // kilograms
        System.out.println("Cash found: " + total(cash));
        System.out.println("Total weight: " + total(weights));
    }
}
Newest tag: 104
Last by name: umbrella
Cash found: 65.0
Total weight: 2.0

Điều này có hợp lý không? 20 + 5 + 40 là 65, có .0 vì kiểu double, và một tổng nhỏ hơn giá trị đơn lẻ lớn nhất rõ ràng là sai. Hãy giữ thói quen kiểm tra này cả khi một công cụ AI đưa cho bạn câu trả lời: tự ước chừng kết quả nên là bao nhiêu, rồi so sánh.

Một largest phục vụ cả Integer lẫn String, và một total phục vụ cả Integer lẫn Double. Ngoài câu chuyện này, tham số của chúng sẽ có tên chung như values.

Giới hạn cũng từ chối một số kiểu. Gọi total(items) với kệ String sẽ thất bại với inference variable T has incompatible bounds. Giới hạn trên Number đến từ giới hạn của bạn và giới hạn dưới String đến từ đối số. Bạn đã cố nhét một String vào ô có nhãn “chỉ dành cho số”.

Kiểm tra bẫy: vòng lặp bắt đầu từ 0 hay 1?

largest khởi tạo best là shelf[0] và lặp từ i = 1. Hãy thu nhỏ để kiểm tra. Với một thẻ, {7}, phép thử 1 < 1 là sai, vòng lặp chạy không lần nào, và trả về 7. Đúng. Với một kệ rỗng, shelf[0] ném ra ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0. Kệ rỗng thì không có món lớn nhất, nên hãy kiểm tra shelf.length trước.

Lớp generic: một lớp Bin, nhiều thùng#

Một thùng giữ nhãn của nó suốt thời gian tồn tại. Đó là một lớp generic: một lớp bình thường với một thay đổi, một tham số kiểu ngay sau tên lớp, class Bin<T>. Bên trong, trường, tham số và giá trị trả về có thể dùng T, và các phương thức không khai báo lại nó. Mỗi Bin giữ các món đồ trong một ArrayList<T>, nên một Bin<String> chứa một ArrayList<String>.

Hãy thử trước

Các vé 101 và 1000 được bỏ vào thùng tickets. contains(101) và contains(1000) nên in ra gì? Hãy đọc contains trước khi xem kết quả.

Xem đáp án

Cả hai nên in true. Ở lần chạy này, 1000 thì không. Lý do nằm bên dưới kết quả.

LostAndFound.java
import java.util.ArrayList;

class Bin<T> {
    private String label;
    private ArrayList<T> items = new ArrayList<>();

    public Bin(String label) {
        this.label = label;
    }

    public void add(T item) {
        items.add(item);
    }

    public T get(int index) {
        return items.get(index);
    }

    public boolean contains(T target) {
        for (T item : items) {
            if (item == target) {                    // on purpose: see below
                return true;
            }
        }
        return false;
    }

    @Override
    public String toString() {
        return label + " " + items;
    }
}

public class LostAndFound {
    public static void main(String[] args) {
        Bin<String> scarves = new Bin<>("Scarves");
        scarves.add("red wool");
        scarves.add("striped");
        Bin<Integer> tickets = new Bin<Integer>("Tickets");
        tickets.add(101);
        tickets.add(1000);

        String first = scarves.get(0);               // no cast
        int ticket = tickets.get(1);
        System.out.println(scarves);
        System.out.println(tickets);
        System.out.println(first + " / ticket " + ticket);
        System.out.println("Has 101? " + tickets.contains(101));
        System.out.println("Has 1000? " + tickets.contains(1000));
    }
}
Scarves [red wool, striped]
Tickets [101, 1000]
red wool / ticket 1000
Has 101? true
Has 1000? false

Một lớp Bin tạo ra hai loại thùng, và mỗi lần get đều không cần ép kiểu.

Dòng cuối cố tình sai, để bạn gặp nó ở đây chứ không phải lúc 2 giờ sáng trước hạn nộp. Các giá trị T luôn là đối tượng, và == trên đối tượng hỏi “cùng một đối tượng?”, không phải “cùng một giá trị?”. Mỗi Integer ở đây đã được autobox, nghĩa là tự động chuyển từ một int thành một đối tượng. Java chỉ đảm bảo dùng chung một đối tượng trong khoảng -128 đến 127. Ngoài khoảng đó thì tùy JVM. Trên một cấu hình chuẩn, như lần chạy ở trên, số 1000 được lưu và số 1000 được tìm là hai đối tượng khác nhau, nên == có thể cho true hoặc false. Chỉ có equals là an toàn.

Kiểm tra bẫy: == hay equals?

Mỗi khi so sánh hai giá trị T, hãy dùng equals. Đổi một dòng trong contains thành if (item.equals(target)), và dòng cuối sẽ thành:

Has 1000? true

Bây giờ là các dòng tạo đối tượng. new Bin<Integer>("Tickets") lặp lại kiểu. new Bin<>("Scarves") để trống cặp ngoặc nhọn, và suy luận điền vào từ biến bên trái. Cặp ngoặc trống này có biệt danh là toán tử diamond. Cả hai đều đúng; đa số lập trình viên dùng diamond.

Bỏ hẳn cặp ngoặc nhọn, new Bin("Scarves"), sẽ tạo ra một kiểu thô (raw type), một Bin không có nhãn nào cả. Trình biên dịch không thể kiểm tra dòng đó, nên nó thêm một ghi chú về “unchecked or unsafe operations”. Nếu khai báo biến là Bin thuần, mọi lần dùng nó đều không được kiểm tra.

Hai tham số kiểu, và một lớp có giới hạn#

Ai nộp một món đồ sẽ nhận một phiếu nhận. Một phiếu ghép hai giá trị có thể thuộc hai kiểu khác nhau, nên nó có hai tham số kiểu, ngăn cách bằng dấu phẩy: class Claim<K, V>.

LostAndFound.java
class Claim<K, V> {
    private K ticket;
    private V item;

    public Claim(K ticket, V item) {
        this.ticket = ticket;
        this.item = item;
    }

    public K getTicket() {
        return ticket;
    }

    public V getItem() {
        return item;
    }

    @Override
    public String toString() {
        return "#" + ticket + " = " + item;
    }
}

public class LostAndFound {
    public static void main(String[] args) {
        Claim<Integer, String> c1 = new Claim<>(104, "umbrella");
        Claim<String, Double> c2 = new Claim<>("B-7", 1.25);
        int number = c1.getTicket();
        String what = c1.getItem();
        System.out.println(number + " is the " + what);
        System.out.println(c1);
        System.out.println(c2);
    }
}
104 is the umbrella
#104 = umbrella
#B-7 = 1.25

Một lớp Claim đã ghép một Integer với một String, và một String với một Double. c1.getItem() là một String vì V là String với c1. Diamond đã điền cả hai đối số kiểu.

Một lớp cũng có thể có giới hạn. Bên trong class WeightLog<T extends Number>, giới hạn cho phép weight.doubleValue(). Bên ngoài, WeightLog<Double> thì được, nhưng WeightLog<String> words; thất bại với type argument String is not within bounds of type-variable T.

Theo quy ước, tham số kiểu là một chữ cái viết hoa: T cho type (kiểu), E cho element (phần tử), K và V cho key và value (khóa và giá trị). Tên hợp lệ nào cũng biên dịch được, nhưng một chữ cái giúp nhìn qua là biết nó không phải một lớp thật. Một lớp tổng quát có hai ô thường được gọi đơn giản là Pair<A, B>.

Không dùng kiểu nguyên thủy làm đối số kiểu#

Đây là lý do kệ thẻ chưa bao giờ là một int[]:

LostAndFound.java
import java.util.ArrayList;

class Bin<T> {
    private ArrayList<T> items = new ArrayList<>();

    public void add(T item) {
        items.add(item);
    }
}

public class LostAndFound {
    public static void main(String[] args) {
        Bin<int> tickets = new Bin<>();
    }
}
LostAndFound.java:13: error: unexpected type
        Bin<int> tickets = new Bin<>();
            ^
  required: reference
  found:    int
1 error

Đối số kiểu phải là một kiểu tham chiếu: một lớp, một giao diện hoặc một kiểu mảng. Tám kiểu nguyên thủy, như int, double, char và boolean, không được phép.

Kiểm tra bẫy: int hay Integer?

Mỗi khi viết một đối số kiểu, hãy kiểm tra nó không phải kiểu nguyên thủy. Hãy dùng lớp bao: Integer, Double, Character, Boolean. tickets.add(101) vẫn chạy được, vì Java autobox số 101.

Những việc generic không làm được: new T() và new T[]#

Vì sao Bin dùng một ArrayList<T>? Đây là phiên bản dùng mảng thuần, cộng thêm một món dự phòng từ hàm tạo của T:

LostAndFound.java
class Bin<T> {
    private T[] items = new T[10];
    private T spare = new T();
}

public class LostAndFound {
    public static void main(String[] args) {
        Bin<String> scarves = new Bin<>();
    }
}
LostAndFound.java:2: error: generic array creation
    private T[] items = new T[10];
                        ^
LostAndFound.java:3: error: unexpected type
    private T spare = new T();
                          ^
  required: class
  found:    type parameter T
  where T is a type-variable:
    T extends Object declared in class Bin
2 errors

Cả hai dòng đều không biên dịch được, vì một lý do chung. Java kiểm tra kiểu generic lúc biên dịch rồi loại bỏ chúng, nên chương trình đang chạy không còn biết T từng là gì. Việc này gọi là xóa kiểu (type erasure). Tạo một đối tượng hay một mảng cần lớp thật, và sau khi xóa kiểu thì không còn lớp nào. (Hơn nữa, T có thể còn không có hàm tạo không tham số.)

Vì vậy hãy lưu nhiều giá trị T trong một ArrayList<T>. Lớp ArrayList<E> của thư viện cũng gặp giới hạn này từ bên trong. Nó giữ các phần tử trong một Object[] thuần. Khi bạn gọi get, trình biên dịch lặng lẽ thêm phép ép kiểu vào mã của bạn, nên bạn không bao giờ phải viết nó.

Hãy tự gõ đoạn này

Đừng dán đoạn này: tự gõ ra là cách để hai vị trí của <T> in vào trí nhớ. Hãy thêm một phương thức static binOf(String label, T[] shelf) trả về một Bin mới chứa mọi món trên kệ. Hãy thử nó với items và tags.

Xem đáp án

Phương thức này là generic, nên <T> đứng trước kiểu trả về. Kiểu trả về là một lớp generic, nên T xuất hiện hai lần liên tiếp:

public static <T> Bin<T> binOf(String label, T[] shelf) {
    Bin<T> bin = new Bin<>(label);
    for (T item : shelf) {
        bin.add(item);
    }
    return bin;
}
Desk [umbrella, scarf, keys]
Tags [104, 101, 103]

Suy luận khiến T là một String, rồi là một Integer, nên mỗi thùng trả về đều đã có nhãn sẵn.

Điều mới trong bài hướng dẫn này#

  1. Một tham số kiểu <T> là một chỗ trống mà một đối số kiểu điền vào.
  2. Phiên bản dùng Object cần các phép ép kiểu có thể thất bại lúc chạy.
  3. Một phương thức generic đặt <T> trước kiểu trả về.
  4. Suy luận kiểu tìm T từ các kiểu của đối số và kiểu đích, không bao giờ từ các giá trị.
  5. Một giới hạn như <T extends Number> hạn chế các kiểu và mở khóa các phương thức của chúng.
  6. Một lớp generic đặt <T> sau tên của nó; diamond <> suy ra nó.
  7. Đối số kiểu là kiểu tham chiếu, và các giá trị T được so sánh bằng equals.
  8. Xóa kiểu loại trừ new T() và new T[n].
Một câu để mang vào phòng thi

<T> là một kiểu trống do người dùng điền vào và trình biên dịch kiểm tra. Nó đứng trước kiểu trả về của phương thức generic và sau tên của lớp generic. Thêm extends để giới hạn các kiểu được phép, nhờ đó bạn gọi được các phương thức của chúng. Đối số kiểu là kiểu tham chiếu, nên hãy viết Integer, không bao giờ viết int.

Những chỗ dễ sai#

  • Quên <T> trước kiểu trả về của phương thức generic. Trình biên dịch tìm một lớp tên T và báo cannot find symbol.
  • Lặp lại <T> trên một phương thức bên trong lớp generic. public <T> void add(T item) bên trong Bin<T> khai báo một T thứ hai, không liên quan. Khi đó items.add(item) thất bại với T#1 cannot be converted to T#2.
  • Dùng kiểu nguyên thủy làm đối số kiểu. Bin<int> thất bại; hãy dùng Bin<Integer>.
  • Truyền một int[] vào phương thức nhận T[]. T không thể là int, nên hãy dùng một Integer[].
  • Gọi compareTo trên một T thông thường. Một T thông thường chỉ có các phương thức của Object. Hãy giới hạn nó: <T extends Comparable<T>>.
  • Viết implements trong một giới hạn. Giới hạn luôn dùng extends.
  • So sánh các giá trị T bằng ==. Nó hỏi “cùng một đối tượng?”, và với Integer lớn hơn 127 thì câu trả lời tùy vào JVM. Hãy dùng equals.
  • Bỏ cặp ngoặc nhọn: new Bin("Scarves"). Đó là kiểu thô, một Bin không có nhãn, nên trình biên dịch không thể kiểm tra. Hãy viết new Bin<>("Scarves").
  • Viết new T() hoặc new T[n]. Cả hai đều không biên dịch được vì xóa kiểu; hãy dùng một ArrayList<T>.

Trong bài thi: “viết một phương thức generic” chỉ có nghĩa là phương thức, và điểm thường bị mất vì thiếu <T> trước kiểu trả về. Với “viết một lớp generic”, <T> chỉ đặt sau tên lớp. Hãy đọc đề hai lần, trả lời, rồi đọc lại để kiểm tra bạn đã làm đủ mọi phần.

Luyện tập#

Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.

  1. Trong public static <T> T first(T[] arr), mỗi chữ trong ba chữ T có nghĩa là gì?
  2. Viết một phương thức generic countMatches(T[] items, T target) trả về số phần tử bằng target. Hãy thử nó trên String và Integer.
  3. Vì sao đoạn này không biên dịch được, và sửa thế nào?
    public static <T> T bigger(T a, T b) {
        if (a.compareTo(b) > 0) return a;
        return b;
    }
  4. Viết một lớp generic Box<T> với một hàm tạo, get, set và isEmpty (true khi nội dung là null).
  5. Viết một phương thức generic có giới hạn trả về phần tử nhỏ nhất của một mảng, và cho thấy nó chạy trên Integer và String.
  6. Những dòng nào biên dịch được? Pair<String, Integer> a = new Pair<>("x", 1);   Pair<String, int> b;   Stats<String> c; với class Stats<T extends Number>.

Lời giải#

  1. Chữ đầu tiên, trong <T>, khai báo tham số kiểu. Chữ thứ hai là kiểu trả về: phương thức trả về một T. Chữ thứ ba cho biết tham số là một mảng T. Khi gọi với một String[], cả ba đều trở thành String.
  2. Hãy dùng equals, thứ mà mọi đối tượng đều có, nên không cần giới hạn:
    public class QCount {
        public static <T> int countMatches(T[] items, T target) {
            int count = 0;
            for (T item : items) {
                if (item.equals(target)) {
                    count++;
                }
            }
            return count;
        }
    
        public static void main(String[] args) {
            String[] votes = {"yes", "no", "yes", "yes"};
            Integer[] dice = {6, 2, 6};
            System.out.println(countMatches(votes, "yes"));
            System.out.println(countMatches(dice, 6));
        }
    }
    3
    2
  3. Một T thông thường có thể là kiểu bất kỳ, và không phải kiểu nào cũng có compareTo, nên trình biên dịch báo cannot find symbol. Hãy thêm một giới hạn để chỉ các kiểu có thể so sánh được phép dùng: public static <T extends Comparable<T>> T bigger(T a, T b).
  4. Mọi chỗ lẽ ra ghi một kiểu cụ thể thì thay bằng T:
    class Box<T> {
        private T contents;
    
        public Box(T contents) {
            this.contents = contents;
        }
    
        public T get() {
            return contents;
        }
    
        public void set(T contents) {
            this.contents = contents;
        }
    
        public boolean isEmpty() {
            return contents == null;
        }
    }
    
    public class QBox {
        public static void main(String[] args) {
            Box<String> b = new Box<>("socks");
            System.out.println(b.get() + " " + b.isEmpty());
            b.set(null);
            System.out.println(b.isEmpty());
        }
    }
    socks false
    true
  5. Giới hạn T là Comparable<T> để compareTo được phép dùng:
    public class QMin {
        public static <T extends Comparable<T>> T smallest(T[] items) {
            T min = items[0];
            for (T item : items) {
                if (item.compareTo(min) < 0) {
                    min = item;
                }
            }
            return min;
        }
    
        public static void main(String[] args) {
            Integer[] n = {8, 3, 9};
            String[] s = {"kiwi", "fig", "lime"};
            System.out.println(smallest(n));
            System.out.println(smallest(s));
        }
    }
    3
    fig
  6. Chỉ dòng đầu tiên. int là kiểu nguyên thủy và không thể là đối số kiểu, còn String không phải là một Number, nên nó nằm ngoài giới hạn của Stats.

Danh sách kiểm tra trước khi thi#

Đây là các mục trong danh sách chủ đề Bài thi 2 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.

  • ☐  Tôi có thể giải thích generic là gì và vì sao nó giúp bắt lỗi lúc biên dịch.
  • ☐  Tôi có thể viết và gọi các phương thức generic, với tham số kiểu đặt trước kiểu trả về.
  • ☐  Tôi có thể viết generic có giới hạn với extends và giải thích giới hạn cho phép điều gì.
  • ☐  Tôi có thể viết và dùng các lớp generic với một hoặc nhiều tham số kiểu.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

40 câu hỏi luyện tập về phương thức generic, lớp generic và giới hạn, mọi đáp án mã đều đã được kiểm tra bằng cách biên dịch và chạy. Miễn phí, dùng ngoại tuyến, không cần tài khoản.

Luyện tập generic →

Câu hỏi thường gặp#

Generic trong Java là gì?

Generic cho phép viết một lớp hoặc phương thức với một tham số kiểu, thường là T, được thay bằng một kiểu thật khi lớp hoặc phương thức đó được dùng. Khi đó trình biên dịch kiểm tra mọi lần sử dụng theo kiểu ấy, bắt lỗi lúc biên dịch và không cần ép kiểu nữa.

Viết phương thức generic trong Java như thế nào?

Khai báo tham số kiểu trong dấu ngoặc nhọn ngay trước kiểu trả về, rồi dùng nó như một kiểu bình thường: public static <T> void printAll(T[] items). Người gọi thường không cần nêu kiểu; Java tự suy ra từ các đối số.

Kiểu generic có giới hạn là gì?

Một tham số kiểu bị giới hạn trong một lớp hoặc giao diện cùng các kiểu con của nó, viết bằng extends, ví dụ <T extends Number> hoặc <T extends Comparable<T>>. Giới hạn này hạn chế các kiểu được dùng, và đổi lại cho phép mã gọi các phương thức của kiểu đó, như doubleValue() hoặc compareTo().

Viết lớp generic trong Java như thế nào?

Đặt các tham số kiểu sau tên lớp, như trong class Pair<A, B>, rồi dùng A và B làm kiểu của trường, tham số và giá trị trả về. Tạo đối tượng với các kiểu được điền vào: new Pair<String, Integer>("Ana", 20), hoặc new Pair<>("Ana", 20) khi dùng toán tử diamond.

Vì sao không dùng được int với generic?

Đối số kiểu phải là kiểu tham chiếu, còn int là kiểu nguyên thủy. Hãy dùng lớp bao Integer; Java tự động chuyển qua lại giữa int và Integer nhờ autoboxing.

Vì sao không tạo được mảng generic bằng new T[]?

Vì xóa kiểu (type erasure): Java kiểm tra kiểu generic lúc biên dịch rồi loại bỏ chúng, nên lúc chạy Java không biết T là gì và không thể tạo mảng của đúng kiểu đó. Hãy dùng ArrayList<T> thay thế.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.