ทำไมอินเทอร์เฟซไม่สามารถใช้อินเทอร์เฟซอื่นได้?

ที่ฉันหมายถึงคือ:

interface B {...}

interface A extends B {...} // allowed  

interface A implements B {...} // not allowed

ฉัน googled และฉันพบสิ่งนี้ :

implementsหมายถึงการกำหนดการใช้งานสำหรับวิธีการของอินเทอร์เฟซ อย่างไรก็ตามอินเทอร์เฟซไม่มีการใช้งานดังนั้นจึงเป็นไปไม่ได้

อย่างไรก็ตามอินเทอร์เฟซเป็นคลาสนามธรรม 100% และคลาสนามธรรมสามารถใช้อินเทอร์เฟซ (คลาสนามธรรม 100%) ได้โดยไม่ต้องใช้วิธีการ อะไรคือปัญหาเมื่อกำหนดเป็น "อินเทอร์เฟซ"

ในรายละเอียด

interface A {
    void methodA();
}

abstract class B implements A {} // we may not implement methodA() but allowed

class C extends B {
   void methodA(){}
} 

interface B implements A {} // not allowed. 
//however, interface B = %100 abstract class B

implementsหมายถึงการนำไปใช้เมื่อinterfaceมีการประกาศเพียงเพื่อให้interfaceไม่นำไปใช้งาน

100% abstract classเทียบเท่ากับการทำงานinterfaceแต่ยังสามารถนำไปใช้งานได้หากคุณต้องการ (ในกรณีนี้จะไม่คงอยู่ 100% abstract) ดังนั้นจากมุมมองของ JVM จึงเป็นคนละสิ่งกัน

นอกจากนี้ยังมีตัวแปรสมาชิกในระดับนามธรรม 100% สามารถมีรอบคัดเลือกเข้าถึงใด ๆ public static finalที่ในอินเตอร์เฟซที่พวกเขาเป็นโดยปริยาย

implementsหมายความว่าพฤติกรรมจะถูกกำหนดสำหรับabstractวิธีการ (ยกเว้นคลาสนามธรรมอย่างชัดเจน) คุณกำหนดการใช้งาน

extends หมายความว่ามีการถ่ายทอดพฤติกรรม

ด้วยอินเทอร์เฟซเป็นไปได้ที่จะกล่าวได้ว่าอินเทอร์เฟซหนึ่งควรมีลักษณะการทำงานเหมือนกับอีกอินเทอร์เฟซไม่มีแม้แต่การนำไปใช้งานจริง นั่นเป็นเหตุผลว่าทำไมอินเทอร์เฟซextendsกับอินเทอร์เฟซอื่นจึงเหมาะสมกว่าแทนที่จะใช้อินเทอร์เฟซ

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

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

อย่างไรก็ตามอินเทอร์เฟซเป็นคลาสนามธรรม 100% และคลาสนามธรรมสามารถใช้อินเทอร์เฟซ (คลาสนามธรรม 100%) ได้โดยไม่ต้องใช้วิธีการ อะไรคือปัญหาเมื่อกำหนดเป็น "อินเทอร์เฟซ"

นี่เป็นเพียงเรื่องของแบบแผน ผู้เขียนภาษาจาวาตัดสินใจว่า "ขยาย" เป็นวิธีที่ดีที่สุดในการอธิบายความสัมพันธ์นี้นั่นคือสิ่งที่เราทุกคนใช้

โดยทั่วไปแล้วแม้ว่าอินเทอร์เฟซจะเป็น "คลาสนามธรรม 100%" แต่เราก็ไม่ได้คิดเช่นนั้น เรามักคิดว่าอินเทอร์เฟซเป็นคำมั่นสัญญาที่จะใช้วิธีการหลักบางอย่างแทนที่จะเป็นคลาสที่ได้รับมา ดังนั้นเราจึงมักจะใช้ภาษาที่แตกต่างกันสำหรับอินเทอร์เฟซมากกว่าสำหรับคลาส

ตามที่รัฐอื่นระบุมีเหตุผลที่ดีในการเลือก "ขยาย" มากกว่า "การดำเนินการ"

หวังว่านี่จะช่วยคุณได้เล็กน้อยในสิ่งที่ฉันได้เรียนรู้ใน oops (core java) ระหว่างเรียนที่วิทยาลัย

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

นี่คือตัวอย่างด้านล่างนี่คือความเข้าใจของฉันและสิ่งที่ฉันได้เรียนรู้ในโอ๊ะโอ

interface ParentInterface{  
        void myMethod();  
}  

interface SubInterface extends ParentInterface{  
        void anotherMethod();  
}  

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

public interface Dog
{
    public boolean Barks();

    public boolean isGoldenRetriever();
}

ตอนนี้ถ้าคลาสต้องใช้อินเทอร์เฟซนี้จะมีลักษณะดังนี้:

public class SomeClass implements Dog
{
    public boolean Barks{
    // method definition here

    }

    public boolean isGoldenRetriever{
    // method definition here
    }
}

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

public abstract class MyAbstractClass {

    public abstract void abstractMethod();
}

นี่คือตัวอย่างคลาสย่อยของ MyAbstractClass:

public class MySubClass extends MyAbstractClass {

    public void abstractMethod() {
        System.out.println("My method implementation");
    }
}

อินเทอร์เฟซเป็นเหมือนนามธรรมที่ไม่ได้ให้ฟังก์ชันการทำงานใด ๆ ดังนั้นจึงไม่ 'ใช้งาน' แต่ขยายนามธรรมหรือส่วนต่อประสานอื่น ๆ

อินเทอร์เฟซเป็นคลาสที่มีเมธอดนามธรรมที่ไม่สามารถสร้างอ็อบเจ็กต์ใด ๆ ได้เนื่องจากอินเทอร์เฟซไม่สามารถสร้างอ็อบเจ็กต์และไม่ใช่คลาสที่บริสุทธิ์จึงไม่คุ้มที่จะนำไปใช้