Warum kann der Java-Compiler die Vererbung nicht richtig ableiten?

Question

Antwort läuft darauf hinaus, eine similar question

-Java does not support lower bounds on parameterized methods, because such a feature is "not useful enough" finden Sie die folgenden Ausschnitt Gegeben:

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

Ohne die explizite Umwandlung zu R in TypicalJavaFooBar#foobar Compiler mit dem folgenden Fehler fehlschlägt

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

Meine Frage ist warum? Für mich scheint es, dass der Compiler genügend Informationen haben sollte, da TypicalJavaFooBar klar definiert ist, sowohl Foo als auch Bar zu implementieren; Warum ist das nicht genug, um die Foo & Bar Einschränkung zu erfüllen?

UPDATE

Das Hauptziel dieser Übung ist es, den folgenden Auftrag zu definieren: Aufruf der Methode foobar auf einer Instanz eines FooBar garantiert etwas zurückzukehren, die sowohl Foo und Bar implementiert.

Answer 1

Der Typparameter R ist an die Methode durch den aufrufenden Code gebunden und könnte theoretisch Baz implements Foo, Bar; siehe zB Collections.emptySet(), dessen Typparameter vom Aufrufer bestimmt wird und von einem Typzeugen beeinflusst werden kann.

Um zu tun, was Sie anscheinend versuchen, müssten Sie den Typ Parameter auf die Schnittstelle FooBar verschieben und TypicalJavaFooBar implements Foo, Bar, FooBar<TypicalJavaFooBar> haben.

Answer 2

Ihre R kann jeder Art sein, die ein Foo & Bar ist so können Sie

class MyFooBar implements Foo, Bar { ... 


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

Answer 3

Nein schreiben, kann der Compiler nicht die Art von R Inferenz und Ihre Besetzung ist falsch. Um zu sehen, warum gerade Ihre Klasse wie folgt erweitern:

static class C extends TypicalJavaFooBar { 

    void eat() {} 

    @Override 
    public void bar() {} 

    @Override 
    public void foo() {} 
} 

Dann Ihre Cast ermöglicht dies:

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

, die in einem Runtime Ergebnisse:

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

Aus diesem Grund - - Die Entwickler des Compilers würden das sicherlich nicht zulassen. Es ist etwas falsch im Code, daher die Notwendigkeit der Besetzung.

Answer 4

Wenn Sie dies in Java verwenden könnte

if (obj instanceof (Foo & Bar)) 

dann würden Sie nicht die Besetzung machen gezwungen werden.