การนำสองอินเตอร์เฟสมาใช้ในคลาสด้วยวิธีเดียวกัน วิธีการอินเทอร์เฟซใดถูกแทนที่

สองอินเตอร์เฟสที่มีชื่อเมธอดและลายเซ็นเหมือนกัน แต่ดำเนินการโดยชั้นเดียวแล้ววิธีการรวบรวมจะระบุวิธีการที่เป็นอินเตอร์เฟซที่?

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

หากชนิดใช้สองอินเตอร์เฟสและแต่ละinterfaceวิธีกำหนดว่ามีลายเซ็นเหมือนกันดังนั้นจะมีเพียงวิธีเดียวเท่านั้นและจะไม่แยกความแตกต่าง หากกล่าวว่าทั้งสองวิธีมีประเภทผลตอบแทนที่ขัดแย้งกันมันจะเป็นข้อผิดพลาดในการรวบรวม นี่คือกฎทั่วไปของการสืบทอดวิธีการเอาชนะการซ่อนเร้นและการประกาศและนำไปใช้กับความขัดแย้งที่เป็นไปได้ไม่เพียง แต่ระหว่างinterfaceวิธีที่สืบทอดมา 2 วิธีเท่านั้น แต่ยังinterfaceเป็นclassวิธีการที่ยอดเยี่ยมและหรือแม้แต่ความขัดแย้ง

ตัวอย่างความเข้ากันได้

นี่คือตัวอย่างที่คุณมีinterface Giftซึ่งมีpresent()วิธีการ (ในขณะที่นำเสนอของขวัญ) และยังมีinterface Guestซึ่งนอกจากนี้ยังมีpresent()วิธีการ (ในขณะที่ผู้เข้าพักเป็นปัจจุบันและไม่ขาด)

Presentable johnnyเป็นทั้งและGiftGuest

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

ตัวอย่างโค้ดข้างต้นรวบรวมและเรียกใช้

โปรดทราบว่ามีเพียง @Override สิ่งเดียวที่จำเป็น !!! . นี่เป็นเพราะGift.present()และGuest.present()เป็น " @Override-quivalent" ( JLS 8.4.2 )

ดังนั้นจึงjohnny มีเพียงหนึ่งการดำเนินงานของpresent()และมันไม่สำคัญว่าคุณรักษาjohnnyไม่ว่าจะเป็นGiftหรือเป็นGuestมีเพียงวิธีการหนึ่งที่จะเรียก

ตัวอย่างที่เข้ากันไม่ได้

นี่คือตัวอย่างที่ทั้งสองวิธีการสืบทอดไม่@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()ประเภทผลตอบแทนที่เข้ากันไม่ได้: หนึ่งอื่น ๆvoid booleanด้วยเหตุผลเดียวกันกับที่คุณไม่สามารถvoid present()และ a boolean present()ในหนึ่งประเภทตัวอย่างนี้ส่งผลให้เกิดข้อผิดพลาดในการรวบรวม

สรุป

คุณสามารถสืบทอดวิธีการที่มี@Override- เทียบเท่าภายใต้ข้อกำหนดปกติของวิธีการแทนที่และซ่อน เนื่องจากพวกเขาเป็น @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 เพื่อรับปัญหาการสืบทอดหลายอย่าง แต่ก็ยังไม่เป็นปัญหาแบบ diamon

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.

เท่าที่คอมไพเลอร์เป็นห่วงทั้งสองวิธีจะเหมือนกัน จะมีการดำเนินการอย่างใดอย่างหนึ่งของทั้งสอง

นี่ไม่ใช่ปัญหาหากทั้งสองวิธีมีความเหมือนกันอย่างมีประสิทธิภาพโดยที่พวกเขาควรจะมีการใช้งานแบบเดียวกัน หากพวกเขาแตกต่างกันตามสัญญา (ตามเอกสารสำหรับแต่ละอินเทอร์เฟซ) คุณจะมีปัญหา

ไม่มีอะไรจะระบุ อินเทอร์เฟซเฉพาะชื่อเมธอดและลายเซ็นเท่านั้น ถ้าทั้งสองอินเตอร์เฟสมีเมธอดที่มีชื่อและลายเซ็นเหมือนกันคลาสการนำไปใช้นั้นสามารถใช้ทั้งสองวิธีอินเตอร์เฟสด้วยวิธีรูปธรรมเดียว

อย่างไรก็ตามหากสัญญาความหมายของวิธีการเชื่อมต่อทั้งสองนั้นขัดแย้งกันคุณจะสูญเสียไปมาก คุณไม่สามารถใช้อินเทอร์เฟซทั้งสองในชั้นเดียวแล้ว

ลองปรับใช้อินเตอร์เฟสเป็นแบบไม่ระบุชื่อ

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

}

}

ในอินเทอร์เฟซเราเพิ่งประกาศวิธีคลาสคอนกรีตที่ใช้อินเทอร์เฟซเหล่านี้ทั้งสองเข้าใจว่ามีเพียงวิธีเดียว (ตามที่คุณอธิบายทั้งสองมีชื่อเดียวกันในประเภทกลับ) ดังนั้นไม่ควรมีปัญหากับมันคุณจะสามารถกำหนดวิธีการนั้นในคลาสที่เป็นรูปธรรม

แต่เมื่อสองอินเตอร์เฟสมีเมธอดที่มีชื่อเหมือนกัน แต่ชนิดการส่งคืนที่แตกต่างกันและคุณใช้สองวิธีในคลาสคอนกรีต:

โปรดดูรหัสด้านล่าง:

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 และมันจะรับมัน แต่ก็ยังทำให้เกิดข้อผิดพลาดในการคอมไพล์เวลาที่ return type ไม่เข้ากันกับ method ของ InterfaceB

ดังนั้นจึงไปยุ่งเหยิงสำหรับคอมไพเลอร์

ด้วยวิธีนี้คุณจะไม่สามารถใช้สองอินเทอร์เฟซที่มีวิธีการชื่อเดียวกัน แต่กลับชนิดที่แตกต่างกัน

ถ้าพวกเขาทั้งคู่เหมือนกันมันก็ไม่สำคัญ มันใช้ทั้งสองวิธีด้วยวิธีรูปธรรมเดียวต่อวิธีส่วนต่อประสาน