Tại sao chúng ta không thể chụp các ký tự đại diện cho phương thức với hai tham số?

Question

Liên quan đến câu hỏi that.

Tôi biết về ký tự đại diện. Ví dụ, sau đây có thể được sử dụng để đảo ngược một danh sách:

public static void reverse(List<?> list) { rev(list); } //capturing the wildcard 
private static <T> void rev(List<T> list) { 
    List<T> tmp = new ArrayList<T>(list); 
    for (int i = 0; i < list.size(); i++) { 
     list.set(i, tmp.get(list.size()-i-1)); 
    } 
} 

Bây giờ tôi đang cố gắng để viết điều tương tự cho rằng loại tình huống:

private int compare (Comparable<?> upper, Comparable<?> lower){ 
    return comp(upper, lower); //The method comp(Comparable<T>, Comparable<T>) is not applicable for the arguments (Comparable<capture#5-of ?>, Comparable<capture#6-of ?>) 
} 

private <T> int comp(Comparable<T> upper, Comparable<T> lower){ 
    return upper.compareTo((T) lower); 
} 

tôi mong đợi rằng nó đã được biên soạn tốt cũng. Có thể chụp wildacrds cho các phương thức có hai hoặc nhiều tham số theo cách đó không?

Answer 1

Trong phương pháp này

private <T> int comp(Comparable<T> upper, Comparable<T> lower){ 
    return upper.compareTo((T) lower); 
} 

cả các thông số chia sẻ cùng một kiểu tham số.

Trong khi đó, điều này là không đúng đối với phương pháp khác:

private int compare (Comparable<?> upper, Comparable<?> lower){ 
    return comp(upper, lower); 
} 

Ở đây, trình biên dịch không có bằng chứng cho thấy các kiểu tham số cho upper và lower đều giống nhau và đó là lý do tại sao từ chối cung cấp cho ánh sáng màu xanh lá cây để biên dịch.

Nếu bạn muốn cả hai phương pháp chia sẻ cùng một tham số kiểu, bạn có thể đặt tham số kiểu lớp vi phạm. Ví dụ:

public class YourClass<T> { 
    private int comp(Comparable<T> upper, Comparable<T> lower){ 
     return upper.compareTo((T) lower); 
    } 

    private int compare (Comparable<T> upper, Comparable<T> lower){ 
     return comp(upper, lower); 
    } 
} 

Một lựa chọn khác (nếu bạn không thích cái đầu tiên) sẽ được giới thiệu một và phía trên cùng ràng buộc đối với loại-thông số cho comp() và compare(). Ví dụ:

private <T extends SomeSuperClass> int comp(Comparable<T> upper, Comparable<T> lower){ 
    return upper.compareTo((T) lower); 
} 

private <T extends SomeSuperClass> int compare (Comparable<T> upper, Comparable<T> lower){ 
    return comp(upper, lower); 
} 

Hơn nữa, nếu bạn muốn tránh những đúc trong phương pháp comp(), bạn có thể làm:

public class YourClass<T extends SomeSuperClass & Comparable<T>> { 
    private int comp(T upper, T lower){ 
     return upper.compareTo(lower); 
    } 

    private int compare (T upper, T lower){ 
     return comp(upper, lower); 
    } 
} 

Answer 2

Bởi vì, như tôi đã nói trong câu trả lời của tôi cho câu hỏi khác của bạn, trình biên dịch không thể biết rằng hai đứng ? đứng cho cùng một loại.

Hai số ? từng đứng cho một số loại không xác định. Phương thức compare cần hai đối tượng Comparable cho cùng một loại T. Nếu bạn gọi compare từ phương thức comp, trình biên dịch không thể chắc chắn rằng hai giá trị ? có cùng loại.