同じメソッドを使用して、クラスに2つのインターフェースを実装します。どのインターフェイスメソッドがオーバーライドされますか？

同じメソッド名とシグニチャーを持つ2つのインターフェース。しかし、単一のクラスによって実装された場合、コンパイラーはどのメソッドがどのインターフェースに対応するかをどのように識別するのでしょうか？

例：

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

型が2つのインターフェースを実装し、それぞれinterfaceが同一のシグニチャーを持つメソッドを定義する場合、実際には1つのメソッドしかなく、それらは区別できません。たとえば、2つのメソッドの戻り値の型が競合している場合は、コンパイルエラーになります。これは、継承、メソッドのオーバーライド、非表示、宣言の一般的なルールであり、2つの継承されたinterfaceメソッド間だけでなくinterface、スーパーclassメソッドとの競合、またはジェネリックの型消去による競合にも適用されます。

互換性の例

ここでは、持っている例ですinterface Giftあり、present()（提示贈り物、のような）方法を、またinterface Guestもあり、present()この方法は、（のように、ゲストが存在し、不在ではありません）。

Presentable johnnyGiftと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!!!"
    }
}

上記のスニペットがコンパイルされて実行されます。

必要なのは1つだけ であることに注意してください@Override !!! 。これは、Gift.present()およびGuest.present()が「@Override-equivalent」であるためです（JLS 8.4.2）。

このように、johnny 一つだけの実装があるのをpresent()、そしてあなたがどのように扱うかは問題ではないjohnnyかなど、GiftまたはとしてGuest、起動する唯一の方法があります。

非互換性の例

以下は、継承された2つのメソッドが@Override同等ではない例です。

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"
}

これは、メンバーを継承しinterfaceなければならないことは、メンバー宣言の一般的なルールに従う必要があることをさらに繰り返します。ここでは、持っているGiftとGuest定義しpresent()、互換性のない戻り値の型と：1 void他boolean。void present()とboolean present()を1つの型に入れることができないのと同じ理由で、この例ではコンパイルエラーが発生します。

概要

@Overrideメソッドのオーバーライドと非表示の通常の要件に従って、同等のメソッドを継承できます。彼らは以来ARE @Override換算、効果的に実施するための唯一の方法があるので、から選択/区別するものは何もありません。

コンパイラーは、どのメソッドがどのインターフェースに対応するものであるかを識別する必要はありません。これは@Override、それらが同等であると判断されると、同じメソッドになるためです。

潜在的な非互換性を解決するのは難しい作業ですが、それはまったく別の問題です。

参考文献

• JLS 8.4.2メソッドシグネチャ
• JLS 8.4.8継承、オーバーライド、および非表示
• JLS 8.4.8.3オーバーライドおよび非表示の要件
• JLS 8.4.8.4オーバーライドと同等の署名を持つメソッドの継承
  • 「クラスは、オーバーライドと同等のシグネチャを持つ複数のメソッドを継承することが可能です。」

これはこの質問の複製としてマークされました/programming/24401064/understanding-and-solving-the-diamond-problems-in-java

多重継承の問題を取得するにはJava 8が必要ですが、それ自体はまだダイアモンドの問題ではありません。

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.

JB Nizetがコメントするので、これを私のオーバーライドで修正できます。

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

ただし、問題はありません

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.

コンパイラに関する限り、これら2つの方法は同じです。両方の実装が1つあります。

2つのメソッドが実質的に同一である場合、これらは同じ実装である必要があるため、これは問題ではありません。それらが契約上異なる場合（各インターフェイスのドキュメントに従って）、問題が発生します。

識別する必要はありません。インターフェイスはメソッド名とシグネチャのみを禁止します。両方のインターフェースにまったく同じ名前とシグニチャーのメソッドがある場合、実装クラスは、1つの具象メソッドで両方のインターフェースメソッドを実装できます。

ただし、2つのインターフェイスメソッドのセマンティックコントラクトが矛盾している場合は、かなりの部分が失われています。その場合、単一のクラスで両方のインターフェースを実装することはできません。

インターフェースを匿名として実装してみてください。

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(){

}

}

インターフェイスと同様に、メソッドを宣言しているだけです。これらの両方のインターフェイスを実装するコンクリートクラスは、メソッドが1つしかないことを理解しています（説明したように、両方とも戻り値の型で同じ名前を持っています）。したがって、問題はありません。そのメソッドを具象クラスで定義できます。

ただし、2つのインターフェースに同じ名前で戻り値の型が異なるメソッドがあり、具象クラスに2つのメソッドを実装する場合：

以下のコードを見てください：

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

コンパイラがメソッド「public void print（）」を取得すると、最初にInterfaceAを検索して取得します。ただし、戻り値の型がInterfaceBのメソッドと互換性がないというコンパイル時エラーが発生します。

したがって、コンパイラーにとっては問題になります。

このようにして、同じ名前のメソッドで戻り値の型が異なる2つのインターフェースを実装することはできません。

まあ、両方が同じであれば問題ありません。インターフェースメソッドごとに1つの具象メソッドで両方を実装します。