Java 为什么接口方法没有主体

为了实现多重继承，我们必须使用接口，但是为什么接口方法没有主体，为什么它们必须在派生类中被重写

---

<>我真的想要一个清晰的答案，不涉及太多的计算机术语，我似乎不能理解这一点，我引用了各种引用< /p> java，因为与C++或Eiffl等语言相比，Java只有多种类型的继承（即接口和一个类），而不是多态的状态和行为继承。后者增加了巨大的复杂性（尤其是状态）

java设计者（和C，对于这一点）选择不包括它，因为C++程序员常常很难调试问题。通过实现多个接口，几乎可以解决大多数需要真正的多重继承的问题，因此这种折衷被认为是值得的

---

请注意，Java 8可能会以虚拟扩展方法的形式出现行为（而不是状态）的多重继承（除非他们像许多其他事情中的一个一样再次推迟），其中接口可以声明一个方法，该方法委托给另一个类中的一个，然后存在于实现该接口的所有类型上。

Java接口包含必须由实现该接口的类实现的方法列表。因此，方法没有主体：每个方法的主体都在实现类中。

接口声明实现类提供什么服务，而不是如何提供服务（这是实现类的工作）。多重继承被认为是不好的，因为它会导致复杂的代码和类层次结构。

接口只有常量变量（public+static+final）和抽象方法（public&abstract）。这些是由实现接口的类使用的

接口只是简单地说“我是一个契约”，如果您希望使用它，它应该遵守一些规则（为所有抽象方法提供实现）

---

在Java中，通过确保一个类只能扩展一个类来省略多重继承，以避免重复。无论如何，通过使用接口，您可以在Java中继承多个类型。

接口方法没有主体 像

因为接口本身不会做任何事情

接口定义了合同。

另一方面，接口定义了类的功能， 事实并非如此。所以界面通常是关于动词的。

因此，Flyable接口什么都不做，只是定义了所植入的契约 FlyableObjects将要飞行。

比如：

---

当然，我们也只能通过接口实现多重继承。

简单回答：

接口为实现提供了标准

说明：
在Java中，接口类似于抽象类，因为其成员未实现。比如说,

public interface Comparable      
{   boolean less(Object m);
    boolean greater(Object m);
    boolean lessEqual(Object m);
    boolean greaterEqual(Object m);
}

接口为实现提供了标准。
使用接口的好处是它们模拟多重继承。Java中的所有类必须只有一个基类，唯一的例外是

Java.lang.Object

（Java类型系统的根类）；java中不允许类的多重继承

所有实例方法都隐式地

public

和

abstract

。您可以这样标记它们，但不鼓励这样做，因为标记被认为是过时的做法。接口本身不需要是公共的，标准库中的几个接口不是公共的，因此只能在内部使用

接口创建类可以实现的协议。请注意，可以像扩展类一样扩展接口（以获得新接口）。实际上可以扩展几个接口接口因此享受多重继承的好处。接口的多重继承几乎没有缺点（小名称冲突问题是一个例外）。在

C++

中，实现的多重继承有很大的缺点。其中包括效率方面的考虑，以及在某些情况下确定将执行哪些代码的语义困难

实现Comparable的多项式类需要实现接口中声明的所有函数

一个类可以选择实现任意数量的接口。实现接口的类必须为该接口的所有方法提供主体。此外，我们希望抽象类可以选择实现接口的一部分，而将其余部分留给非抽象子类

接口的用处远远超出了为其他程序员发布协议的范围。任何函数都可以具有接口类型的参数。实现接口的类中的任何对象都可以作为参数传递

参考文献：

---

如果接口有身体，那么它会带来致命的戴蒙德死亡问题

考虑这个与实体有接口的示例

interface A {
    void print(){ System.out.print("A") }
}

interface B {
    void print(){ System.out.print("B") }
}

interface C extends A, B {
    // now since A and B have bodies interfaces would have had choice to not to override the default behavior
}

public class C_Implementer implements C{
    public static void main(String args[]){
        C c = new C_Implementer();
        c.print(); // gotcha!!!!! what should it print, A or B????
    }
}

您会问“为什么Java不支持实现的多重继承？”

Java教程中讨论了这一点，但我想给出一个实现的多重继承问题的具体示例（以及最后一个新的语言特性解决方案）

设想两个接口（在我们建议的Java版本中，它允许接口方法体）定义了一个同名的方法

public interface FaceOne {
    public void method() {
        System.out.println("FaceOne Version");
    }
}

public interface FaceTwo {
    public void method() {
        System.out.println("FaceTwo Version");
    }
}

一个类实现了这两个接口，但不重写该方法

public class Inheriter implements FaceOne, FaceTwo {

}

当我调用

Inheriter.method（）

时，问题就出现了：输出是打印“FaceOne版本”还是“FaceTwo版本”

此外，我

interface A {
    void print(){ System.out.print("A") }
}

interface B {
    void print(){ System.out.print("B") }
}

interface C extends A, B {
    // now since A and B have bodies interfaces would have had choice to not to override the default behavior
}

public class C_Implementer implements C{
    public static void main(String args[]){
        C c = new C_Implementer();
        c.print(); // gotcha!!!!! what should it print, A or B????
    }
}

public interface FaceOne {
    public void method() {
        System.out.println("FaceOne Version");
    }
}

public interface FaceTwo {
    public void method() {
        System.out.println("FaceTwo Version");
    }
}

public class Inheriter implements FaceOne, FaceTwo {

}

@Override
public void method() {
    FaceOne.super.method();
    FaceTwo.super.method();
    System.out.println("Inheriter Version");
}