Dlaczego kompilator Java nie może prawidłowo dziedziczyć dziedziczenia?

Question

Odpowiedź sprowadza się do Java does not support lower bounds on parameterized methods, because such a feature is "not useful enough", odnoszą się do similar question

Biorąc pod uwagę następujący fragment:

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(); 
    } 
} 

bez wyraźnej obsady do R w TypicalJavaFooBar#foobar kompilator nie powiedzie się z powodu następującego błędu

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

My pytanie brzmi: dlaczego? Wydaje mi się, że kompilator powinien mieć wystarczającą ilość informacji, ponieważ TypicalJavaFooBar jest jednoznacznie zdefiniowany do implementacji zarówno Foo, jak i Bar; dlaczego nie wystarczy, aby spełnić warunek Foo & Bar?

UPDATE

Głównym celem tego ćwiczenia jest określenie następującą umowę: wywołanie metody foobar na instancji FooBar gwarantuje powrót coś który implementuje zarówno Foo i Bar.

Answer 1

Parametr typ R jest związany z metodą kodem wywołującego i może być teoretycznie Baz implements Foo, Bar; patrz na przykład Collections.emptySet(), którego parametr typu jest określany przez dzwoniącego i może na niego wpływać świadek typu.

Aby zrobić to, co najwyraźniej próbujesz, musisz przenieść parametr typu do interfejsu FooBar i mieć TypicalJavaFooBar implements Foo, Bar, FooBar<TypicalJavaFooBar>.

Answer 2

Twój R może być dowolnego typu, który jest Foo & Bar więc można napisać

class MyFooBar implements Foo, Bar { ... 


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

Answer 3

Nie, kompilator nie może wnioskowania typ R a obsada jest źle. Aby zrozumieć, dlaczego, po prostu rozszerzyć swoją klasę tak:

static class C extends TypicalJavaFooBar { 

    void eat() {} 

    @Override 
    public void bar() {} 

    @Override 
    public void foo() {} 
} 

Następnie Twój obsada pozwala na to:

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

co skutkuje RuntimeException:

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

Dlatego - - na pewno projektanci kompilatora nie pozwolą na to. W kodzie jest coś nie tak, stąd wymagana obsada.

Answer 4

Jeśli można to wykorzystać w Javie

if (obj instanceof (Foo & Bar)) 

wtedy nie byłby zmuszony do obsady.