Tại sao trình biên dịch Java không thể suy luận đúng cách thừa kế?

Question

trả lời nắm để Java does not support lower bounds on parameterized methods, because such a feature is "not useful enough", hãy tham khảo một similar question

Với đoạn mã sau:

package demo; 

public class Demo { 
    interface Foo { void foo(); } 
    interface Bar { void bar(); } 
    interface FooBar { 
     <R extends Foo & Bar> R foobar(); 

     static FooBar create() { return new TypicalJavaFooBar(); } 
    } 

    private static final class TypicalJavaFooBar implements Foo, Bar, FooBar { 
     public void bar() { System.out.println("foo"); } 
     public void foo() { System.out.println("bar"); } 

     public <R extends Foo & Bar> R foobar() { 
      return (R) this; 
     } 
    } 

    public static void main(String[] args) { 
     FooBar x = FooBar.create(); 
     Foo foo = x.foobar(); 
     Bar bar = x.foobar(); 
     x.foobar().foo(); 
     x.foobar().bar(); 
    } 
} 

Nếu không có các diễn viên rõ ràng để R trong TypicalJavaFooBar#foobar trình biên dịch không thành công với các lỗi sau

Error:(13, 20) java: incompatible types: demo.Demo.TypicalJavaFooBar cannot be converted to R

My câu hỏi là tại sao? Với tôi, có vẻ như trình biên dịch phải có đủ thông tin kể từ khi TypicalJavaFooBar được xác định rõ ràng để triển khai cả hai Foo và Bar; tại sao không đủ để đáp ứng ràng buộc Foo & Bar?

CẬP NHẬT

Mục đích chính của bài tập này là để xác định các hợp đồng sau: Phương pháp foobar kêu gọi một thể hiện của một FooBar được đảm bảo để trở một cái gì đó mà thực hiện cả hai Foo và Bar.

Answer 1

Thông số loại R được liên kết với phương pháp bằng mã gọi và về mặt lý thuyết có thể là Baz implements Foo, Bar; xem, ví dụ: Collections.emptySet(), có thông số loại được xác định bởi người gọi và có thể bị ảnh hưởng bởi một nhân chứng loại.

Để làm những gì bạn đang cố gắng thực hiện, bạn cần di chuyển thông số loại lên giao diện FooBar và có TypicalJavaFooBar implements Foo, Bar, FooBar<TypicalJavaFooBar>.

Answer 2

bạn R thể được bất kỳ loại mà là một Foo & Bar vì vậy bạn có thể viết

class MyFooBar implements Foo, Bar { ... 


FooBar x = new TypicalJavaFooBar(); 
MyFooBar mfb = x.foobar(); // this compiles now with the cast. 

Answer 3

Không, trình biên dịch không thể suy luận loại R và dàn diễn viên của mình là sai. Để xem lý do tại sao, chỉ cần mở rộng lớp học của bạn như thế này:

static class C extends TypicalJavaFooBar { 

    void eat() {} 

    @Override 
    public void bar() {} 

    @Override 
    public void foo() {} 
} 

Sau đó, dàn diễn viên của bạn cho phép này:

FooBar x = new TypicalJavaFooBar(); 
C c = x.foobar(); 
c.eat(); 

Những kết quả trong một RuntimeException:

Exception in thread "main" java.lang.ClassCastException: demo.Demo$TypicalJavaFooBar cannot be cast to demo.Demo$C 

Đó là lý do tại sao - - chắc chắn các nhà thiết kế của trình biên dịch sẽ không cho phép điều này. Có gì đó sai trong mã, do đó cần sự cần thiết của dàn diễn viên.

Answer 4

Nếu bạn có thể sử dụng điều này trong Java

if (obj instanceof (Foo & Bar)) 

sau đó bạn sẽ không bị buộc phải làm cho các diễn viên.