Sự khác biệt giữa <? mở rộng Base> và <T mở rộng Base>?

Trong ví dụ này:

import java.util.*;

public class Example {
    static void doesntCompile(Map<Integer, List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    static void function(List<? extends Number> outer)
    {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

doesntCompile() không thể biên dịch với:

Example.java:9: error: incompatible types: HashMap<Integer,List<Integer>> cannot be converted to Map<Integer,List<? extends Number>>
        doesntCompile(new HashMap<Integer, List<Integer>>());
                      ^

trong khi compiles()được chấp nhận bởi trình biên dịch.

Câu trả lời này giải thích rằng sự khác biệt duy nhất là không giống như <? ...>, <T ...>cho phép bạn tham khảo loại sau, dường như không phải là trường hợp.

Sự khác biệt giữa <? extends Number>và <T extends Number>trong trường hợp này là gì và tại sao không biên dịch đầu tiên?

Bằng cách xác định phương thức với chữ ký sau:

static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

và gọi nó như:

compiles(new HashMap<Integer, List<Integer>>());

Trong các lọ §8.1.2 chúng tôi tìm thấy, phần đó (phần thú vị được in đậm bởi tôi):

Một khai báo lớp chung định nghĩa một tập hợp các kiểu tham số (§4.5), một kiểu cho mỗi lần gọi có thể của phần tham số kiểu theo đối số kiểu . Tất cả các loại tham số này chia sẻ cùng một lớp trong thời gian chạy.

Nói cách khác, loại Tđược khớp với loại đầu vào và được chỉ định Integer. Chữ ký sẽ có hiệu quả trở thành static void compiles(Map<Integer, List<Integer>> map).

Khi nói đến doesntCompilephương thức, jls định nghĩa các quy tắc của phân nhóm ( §4.5.1 , được in đậm bởi tôi):

Một đối số loại T1 được cho là chứa một đối số loại khác là T2, được viết là <= T1, nếu tập hợp các loại được biểu thị bằng T2 có thể là một tập hợp con của tập hợp các loại được biểu thị bởi T1 theo quy tắc đóng phản xạ và chuyển tiếp của các quy tắc sau ( trong đó <: biểu thị phân nhóm (§4.10)):

• ? kéo dài T <=? kéo dài S nếu T <: S

• ? kéo dài T <=?

• ? siêu T <=? siêu S nếu S <: T

• ? siêu T <=?

• ? siêu T <=? mở rộng đối tượng

• T <= T

• T <=? kéo dài T

• T <=? siêu T

Điều này có nghĩa, ? extends Numberthực sự có chứa Integerhoặc thậm chí List<? extends Number>chứa List<Integer>, nhưng nó không phải là trường hợp cho Map<Integer, List<? extends Number>>và Map<Integer, List<Integer>>. Thêm về chủ đề đó có thể được tìm thấy trong chủ đề SO này . Bạn vẫn có thể làm cho phiên bản có ?ký tự đại diện hoạt động bằng cách khai báo rằng bạn mong đợi một kiểu con của List<? extends Number>:

public class Example {
    // now it compiles
    static void doesntCompile(Map<Integer, ? extends List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    public static void main(String[] args) {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

Trong cuộc gọi:

compiles(new HashMap<Integer, List<Integer>>());

T được khớp với Integer, vì vậy loại đối số là a Map<Integer,List<Integer>>. Đây không phải là trường hợp của phương thức doesntCompile: kiểu của đối số nằm trong Map<Integer, List<? extends Number>>bất kỳ đối số thực tế nào trong cuộc gọi; và đó là không thể chuyển nhượng từ HashMap<Integer, List<Integer>>.

CẬP NHẬT

Trong doesntCompilephương thức, không có gì ngăn cản bạn làm điều gì đó như thế này:

static void doesntCompile(Map<Integer, List<? extends Number>> map) {
    map.put(1, new ArrayList<Double>());
}

Vì vậy, rõ ràng, nó không thể chấp nhận HashMap<Integer, List<Integer>>như là một đối số.

Ví dụ đơn giản về trình diễn. Ví dụ tương tự có thể được hình dung như dưới đây.

static void demo(List<Pair<? extends Number>> lst) {} // doesn't work
static void demo(List<? extends Pair<? extends Number>> lst) {} // works
demo(new ArrayList<Pair<Integer>()); // works
demo(new ArrayList<SubPair<Integer>()); // works for subtype too

public static class Pair<T> {}
public static class SubPair<T> extends Pair<T> {}

List<Pair<? extends Number>>là loại ký tự đại diện đa cấp trong khi đó List<? extends Number>là loại ký tự đại diện tiêu chuẩn.

Các khởi tạo cụ thể hợp lệ của loại thẻ hoang dã List<? extends Number>bao gồm Numbervà bất kỳ kiểu con nào Numbertrong khi đó trong trường hợp List<Pair<? extends Number>>đó là một đối số kiểu của đối số loại và chính nó có một khởi tạo cụ thể của loại chung.

Generics là bất biến nên Pair<? extends Number>loại thẻ hoang dã chỉ có thể chấp nhận Pair<? extends Number>>. Kiểu bên trong ? extends Numberđã covariant. Bạn phải tạo kiểu bao quanh là hiệp phương sai để cho phép hiệp phương sai.

Tôi khuyên bạn nên xem tài liệu về các ký tự đại diện chung, đặc biệt là các hướng dẫn sử dụng ký tự đại diện

Thẳng thắn nói phương pháp của bạn #doesntCompile

static void doesntCompile(Map<Integer, List<? extends Number>> map) {}

và gọi như

doesntCompile(new HashMap<Integer, List<Integer>>());

Về cơ bản là không chính xác

Hãy thêm thực thi pháp lý :

    static void doesntCompile(Map<Integer, List<? extends Number>> map) {
        List<Double> list = new ArrayList<>();
        list.add(0.);
        map.put(0, list);
    }

Nó thực sự tốt, bởi vì Double kéo dài Số, vì vậy đặt List<Double>là hoàn toàn tốt cũng như List<Integer>, phải không?

Tuy nhiên, bạn vẫn cho rằng việc chuyển qua đây từ ví dụ của bạn là hợp phápnew HashMap<Integer, List<Integer>>() ?

Trình biên dịch không nghĩ như vậy và đang cố gắng hết sức để tránh những tình huống như vậy.

Cố gắng thực hiện tương tự với phương thức #compile và trình biên dịch rõ ràng sẽ không cho phép bạn đưa danh sách nhân đôi vào bản đồ.

    static <T extends Number> void compiles(Map<Integer, List<T>> map) {
        List<Double> list = new ArrayList<>();
        list.add(10.);
        map.put(10, list); // does not compile
    }

Về cơ bản bạn có thể đặt gì, nhưng List<T>mà lý do tại sao nó an toàn để gọi phương thức đó với new HashMap<Integer, List<Integer>>()hoặc new HashMap<Integer, List<Double>>()hoặc new HashMap<Integer, List<Long>>()hoặc new HashMap<Integer, List<Number>>().

Vì vậy, tóm lại, bạn đang cố gắng gian lận với trình biên dịch và nó khá bảo vệ chống lại sự gian lận đó.

NB: câu trả lời được đăng bởi Maurice Perry là hoàn toàn chính xác. Tôi chỉ không chắc là nó đủ rõ ràng, vì vậy đã cố gắng (thực sự hy vọng tôi quản lý) để thêm bài viết rộng rãi hơn.