Implementieren von zwei Schnittstellen in einer Klasse mit derselben Methode. Welche Schnittstellenmethode wird überschrieben?

Zwei Schnittstellen mit denselben Methodennamen und Signaturen. Aber wie wird der Compiler dann von einer einzelnen Klasse implementiert, um festzustellen, welche Methode für welche Schnittstelle geeignet ist?

Ex:

interface A{
  int f();
}

interface B{
  int f();
}

class Test implements A, B{   
  public static void main(String... args) throws Exception{   

  }

  @Override
  public int f() {  // from which interface A or B
    return 0;
  }
}   

Wenn ein Typ zwei Schnittstellen implementiert und jeweils interfaceeine Methode mit identischer Signatur definiert, gibt es tatsächlich nur eine Methode, und sie sind nicht unterscheidbar. Wenn die beiden Methoden beispielsweise widersprüchliche Rückgabetypen haben, liegt ein Kompilierungsfehler vor. Dies ist die allgemeine Regel für Vererbung, Überschreiben, Ausblenden und Deklarieren von interfaceMethoden und gilt auch für mögliche Konflikte nicht nur zwischen zwei geerbten Methoden, sondern auch für eine interfaceund eine Supermethode classoder auch nur für Konflikte aufgrund der Typlöschung von Generika.

Kompatibilitätsbeispiel

Hier ist ein Beispiel, in dem Sie eine haben interface Gift, die eine present()Methode hat (wie in, Geschenke präsentieren), und auch eine interface Guest, die auch eine present()Methode hat (wie in, der Gast ist anwesend und nicht abwesend).

Presentable johnnyist sowohl a Giftals auch a Guest.

public class InterfaceTest {
    interface Gift  { void present(); }
    interface Guest { void present(); }

    interface Presentable extends Gift, Guest { }

    public static void main(String[] args) {
        Presentable johnny = new Presentable() {
            @Override public void present() {
                System.out.println("Heeeereee's Johnny!!!");
            }
        };
        johnny.present();                     // "Heeeereee's Johnny!!!"

        ((Gift) johnny).present();            // "Heeeereee's Johnny!!!"
        ((Guest) johnny).present();           // "Heeeereee's Johnny!!!"

        Gift johnnyAsGift = (Gift) johnny;
        johnnyAsGift.present();               // "Heeeereee's Johnny!!!"

        Guest johnnyAsGuest = (Guest) johnny;
        johnnyAsGuest.present();              // "Heeeereee's Johnny!!!"
    }
}

Das obige Snippet wird kompiliert und ausgeführt.

Beachten Sie, dass nur eine @Override erforderlich ist !!! . Dies liegt daran, dass Gift.present()und Guest.present()" @Overrideäquivalent" sind ( JLS 8.4.2 ).

Es gibt also johnny nur eine Implementierung von present(), und es spielt keine Rolle, wie Sie behandeln johnny, ob als Giftoder als Guest, es gibt nur eine Methode, die aufgerufen werden kann.

Beispiel für Inkompatibilität

Hier ist ein Beispiel, in dem die beiden geerbten Methoden NICHT @Override-äquivalent sind:

public class InterfaceTest {
    interface Gift  { void present(); }
    interface Guest { boolean present(); }

    interface Presentable extends Gift, Guest { } // DOES NOT COMPILE!!!
    // "types InterfaceTest.Guest and InterfaceTest.Gift are incompatible;
    //  both define present(), but with unrelated return types"
}

Dies bekräftigt weiter, dass das Erben von Mitgliedern von a interfacedie allgemeine Regel der Mitgliedererklärungen befolgen muss. Hier haben wir Giftund Guestdefinieren present()mit inkompatiblen Rückgabetypen: eine voidder anderen boolean. Aus dem gleichen Grund, aus dem Sie ein void present()und ein boolean present()in einem Typ nicht können, führt dieses Beispiel zu einem Kompilierungsfehler.

Zusammenfassung

Sie können Methoden erben, die @Override-äquivalent sind, vorbehaltlich der üblichen Anforderungen zum Überschreiben und Ausblenden von Methoden. Da sie SIND @Override -Äquivalent, effektiv ist es nur eine Methode zu implementieren, und somit gibt es nichts zu unterscheiden / Auswahl.

Der Compiler muss nicht identifizieren, welche Methode für welche Schnittstelle @Overridegeeignet ist , da sie, sobald festgestellt wurde, dass sie gleichwertig sind, dieselbe Methode sind.

Das Beheben potenzieller Inkompatibilitäten mag eine schwierige Aufgabe sein, aber das ist insgesamt ein anderes Problem.

Verweise

• JLS 8.4.2 Methodensignatur
• JLS 8.4.8 Vererbung, Überschreiben und Verstecken
• JLS 8.4.8.3 Anforderungen beim Überschreiben und Verstecken
• JLS 8.4.8.4 Vererbungsmethoden mit Override-äquivalenten Signaturen
  • "Es ist möglich, dass eine Klasse mehrere Methoden mit überschreibungsäquivalenten Signaturen erbt."

Dies wurde als Duplikat dieser Frage markiert: /programming/24401064/understanding-and-solving-the-diamond-problems-in-java

Sie benötigen Java 8, um ein Mehrfachvererbungsproblem zu erhalten, aber es ist immer noch kein Diamonproblem als solches.

interface A {
    default void hi() { System.out.println("A"); }
}

interface B {
    default void hi() { System.out.println("B"); }
}

class AB implements A, B { // won't compile
}

new AB().hi(); // won't compile.

Wie JB Nizet kommentiert, können Sie dieses Problem beheben.

class AB implements A, B {
    public void hi() { A.super.hi(); }
}

Sie haben jedoch kein Problem mit

interface D extends A { }

interface E extends A { }

interface F extends A {
    default void hi() { System.out.println("F"); }
}

class DE implement D, E { }

new DE().hi(); // prints A

class DEF implement D, E, F { }

new DEF().hi(); // prints F as it is closer in the heirarchy than A.

Für den Compiler sind diese beiden Methoden identisch. Es wird eine Implementierung von beiden geben.

Dies ist kein Problem, wenn die beiden Methoden effektiv identisch sind, da sie dieselbe Implementierung haben sollten. Wenn sie vertraglich unterschiedlich sind (gemäß der Dokumentation für jede Schnittstelle), sind Sie in Schwierigkeiten.

Es gibt nichts zu identifizieren. Schnittstellen verbieten nur einen Methodennamen und eine Signatur. Wenn beide Schnittstellen eine Methode mit genau demselben Namen und derselben Signatur haben, kann die implementierende Klasse beide Schnittstellenmethoden mit einer einzigen konkreten Methode implementieren.

Wenn jedoch die semantischen Verträge der beiden Schnittstellenmethoden widersprüchlich sind, haben Sie ziemlich viel verloren. Sie können dann nicht beide Schnittstellen in einer Klasse implementieren.

Versuchen Sie, die Schnittstelle anonym zu implementieren.

public class MyClass extends MySuperClass implements MyInterface{

MyInterface myInterface = new MyInterface(){

/* Overrided method from interface */
@override
public void method1(){

}

};

/* Overrided method from superclass*/
@override
public void method1(){

}

}

Wie in der Schnittstelle deklarieren wir nur Methoden. Eine konkrete Klasse, die diese beiden Schnittstellen implementiert, versteht, dass es nur eine Methode gibt (wie Sie beschrieben haben, haben beide den gleichen Namen im Rückgabetyp). Es sollte also kein Problem damit geben. Sie können diese Methode in einer konkreten Klasse definieren.

Wenn jedoch zwei Schnittstellen eine Methode mit demselben Namen, aber unterschiedlichem Rückgabetyp haben und Sie zwei Methoden in einer konkreten Klasse implementieren:

Bitte schauen Sie sich den folgenden Code an:

public interface InterfaceA {
  public void print();
}


public interface InterfaceB {
  public int print();
}

public class ClassAB implements InterfaceA, InterfaceB {
  public void print()
  {
    System.out.println("Inside InterfaceA");
  }
  public int print()
  {
    System.out.println("Inside InterfaceB");
    return 5;
  }
}

Wenn der Compiler die Methode "public void print ()" erhält, sucht er zuerst in InterfaceA und erhält sie. Trotzdem gibt er einen Fehler bei der Kompilierung, dass der Rückgabetyp nicht mit der Methode von InterfaceB kompatibel ist.

Für den Compiler geht es also durcheinander.

Auf diese Weise können Sie nicht zwei Schnittstellen mit derselben Methode, sondern unterschiedlichem Rückgabetyp implementieren.

Nun, wenn beide gleich sind, spielt es keine Rolle. Beide werden mit einer einzigen konkreten Methode pro Schnittstellenmethode implementiert.