为什么Java中没有多重继承，但允许实现多个接口？

顾北清歌寒 2024-09-02 17:07:31

因为接口只指定类正在做什么，而不是它如何做。

多重继承的问题在于，两个类可能定义做同一件事的不同方式，而子类无法选择选择哪一种。

转角预定愛 2024-09-02 17:07:31

我的一位大学导师是这样向我解释的：

假设我有一个类，它是烤面包机，另一个类是核弹。他们都可能有“黑暗”的背景。它们都有一个 on() 方法。（一个有一个 off()，另一个没有。）如果我想创建一个类，它是这两个类的子类......正如你所看到的，这是一个真正在我面前爆炸的问题.

因此，主要问题之一是，如果您有两个父类，它们可能对同一功能有不同的实现，或者可能有两个具有相同名称的不同功能，如我的讲师的示例所示。然后你必须决定你的子类将使用哪一个。当然，有很多方法可以处理这个问题——C++就是这么做的——但Java的设计者认为这会让事情变得太复杂。

但是，通过接口，您可以描述类能够执行的操作，而不是借用另一个类的方法来执行操作。与多个父类相比，多个接口不太可能导致需要解决的棘手冲突。

回复收藏 0 原文

茶底世界 2024-09-02 17:07:31

因为继承被过度使用，即使您不能说“嘿，那个方法看起来很有用，我也会扩展那个类”。

public class MyGodClass extends AppDomainObject, HttpServlet, MouseAdapter, 
             AbstractTableModel, AbstractListModel, AbstractList, AbstractMap, ...

Because inheritance is overused even when you can't say "hey, that method looks useful, I'll extend that class as well".

public class MyGodClass extends AppDomainObject, HttpServlet, MouseAdapter, 
             AbstractTableModel, AbstractListModel, AbstractList, AbstractMap, ...

回复收藏 0 原文

静谧 2024-09-02 17:07:31

这个问题的答案在于java编译器的内部工作原理（构造函数链）。
如果我们看到java编译器的内部工作原理：

public class Bank {
  public void printBankBalance(){
    System.out.println("10k");
  }
}
class SBI extends Bank{
 public void printBankBalance(){
    System.out.println("20k");
  }
}

编译后如下所示：

public class Bank {
  public Bank(){
   super();
  }
  public void printBankBalance(){
    System.out.println("10k");
  }
}
class SBI extends Bank {
 SBI(){
   super();
 }
 public void printBankBalance(){
    System.out.println("20k");
  }
}

当我们扩展类并创建它的对象时，一个构造函数链将运行到Object类。

上面的代码可以正常运行。但如果我们有另一个名为 Car 的类，它扩展了 Bank 和一个名为 SBICar 的混合（多重继承）类：

class Car extends Bank {
  Car() {
    super();
  }
  public void run(){
    System.out.println("99Km/h");
  }
}
class SBICar extends Bank, Car {
  SBICar() {
    super(); //NOTE: compile time ambiguity.
  }
  public void run() {
    System.out.println("99Km/h");
  }
  public void printBankBalance(){
    System.out.println("20k");
  }
}

在这种情况下（SBICar）将无法创建构造函数链（编译时歧义）。

对于接口，这是允许的，因为我们无法创建它的对象。

有关 default 和 static 方法的新概念，请参阅界面默认。

希望这能解决您的疑问。
谢谢。

The answer of this question is lies in the internal working of java compiler(constructor chaining).
If we see the internal working of java compiler:

public class Bank {
  public void printBankBalance(){
    System.out.println("10k");
  }
}
class SBI extends Bank{
 public void printBankBalance(){
    System.out.println("20k");
  }
}

After compiling this look like:

public class Bank {
  public Bank(){
   super();
  }
  public void printBankBalance(){
    System.out.println("10k");
  }
}
class SBI extends Bank {
 SBI(){
   super();
 }
 public void printBankBalance(){
    System.out.println("20k");
  }
}

when we extends class and create an object of it, one constructor chain will run till Object class.

Above code will run fine. but if we have another class called Car which extends Bank and one hybrid(multiple inheritance) class called SBICar:

class Car extends Bank {
  Car() {
    super();
  }
  public void run(){
    System.out.println("99Km/h");
  }
}
class SBICar extends Bank, Car {
  SBICar() {
    super(); //NOTE: compile time ambiguity.
  }
  public void run() {
    System.out.println("99Km/h");
  }
  public void printBankBalance(){
    System.out.println("20k");
  }
}

In this case(SBICar) will fail to create constructor chain(compile time ambiguity).

For interfaces this is allowed because we cannot create an object of it.

For new concept of default and static method kindly refer default in interface.

Hope this will solve your query.
Thanks.

回复收藏 0 原文

身边 2024-09-02 17:07:31

您可以在有关多重继承<的oracle文档页面中找到此查询的准确答案< /a>

状态的多重继承：能够从多个类继承字段

在这种情况下，当您创建一个对象时：它将继承所有超类的字段。这会导致两个问题。

a.如果来自不同超类的方法或构造函数实例化同一个字段怎么办？
b.哪个方法或构造函数优先？

实现的多重继承：能够从多个类继承方法定义

这种方法会导致名称冲突和歧义。如果子类和超类包含相同的方法名称（和签名），编译器无法确定要调用哪个版本。

Java 通过默认方法支持这种类型的多重继承，因为Java 8 发布。 Java 编译器提供了一些规则来确定特定类使用哪种默认方法。

有关解决钻石问题的更多详细信息，请参阅下面的 SE 帖子：

Java 8 中抽象类和接口有什么区别？

类型的多重继承：一个类实现多个接口的能力。

由于接口不包含可变字段，因此您不必担心这里由于状态的多重继承而导致的问题。

回复收藏 0 原文

最近可好 2024-09-02 17:07:31

Java 不支持多重继承有两个原因：

在 java 中，每个类都是 Object 类的子类。当它继承自多个超类时，子类就会产生歧义
获取Object类的属性。
在java中，每个类都有一个构造函数，无论我们显式地编写它还是根本不编写它。第一条语句是调用 super() 来调用
超级类构造函数。如果该类有多个超类，则
感到困惑。

因此，当一个类从多个超类扩展时，我们会收到编译时错误。

回复收藏 0 原文

追星践月 2024-09-02 17:07:31

Java 仅通过接口支持多重继承。一个类可以实现任意数量的接口，但只能扩展一个类。

不支持多重继承，因为它会导致致命的钻石问题。然而，它可以解决，但会导致系统复杂，因此多重继承已被 Java 创始人放弃。

James Gosling 在 1995 年 2 月发表的题为“Java：概述”的白皮书中（链接 - 第 2 页）给出了为什么 Java 不支持多重继承的想法。

根据高斯林的说法：

“JAVA 省略了许多很少使用、难以理解、令人困惑的功能
根据我们的经验，C++ 带来的痛苦多于好处。这
主要由运算符重载组成（尽管它确实有
方法重载）、多重继承和广泛的自动
强制。”

回复收藏 0 原文

今天小雨转甜 2024-09-02 17:07:31

实现多个接口非常有用，并且不会给语言实现者或程序员带来太多问题。所以这是允许的。多重继承虽然也很有用，但可能会给用户带来严重的问题（可怕的死亡钻石）。使用多重继承所做的大多数事情也可以通过组合或使用内部类来完成。因此多重继承是被禁止的，因为带来的问题多于收益。

回复收藏 0 原文

天赋异禀 2024-09-02 17:07:31

据说对象状态是根据其中的字段来引用的，如果继承了太多的类，它就会变得不明确。这是链接

http://docs.oracle.com/javase/tutorial /java/IandI/multipleinheritance.html

回复收藏 0 原文

∝单色的世界 2024-09-02 17:07:31

由于这个主题还没有结束，我将发布这个答案，我希望这可以帮助人们理解为什么java不允许多重继承。

考虑下面的类：

public class Abc{

    public void doSomething(){

    }

}

在这种情况下，类 Abc 没有扩展任何东西，对吗？没那么快，这个类隐式扩展了 Object 类，它是允许一切在 java 中工作的基类。一切都是对象。

如果您尝试使用上面的类，您会发现您的 IDE 允许您使用以下方法：equals(Object o)、toString() 等，但是您没有声明这些方法，它们来自基类 Object

你可以尝试：

public class Abc extends String{

    public void doSomething(){

    }

}

这很好，因为你的类不会隐式扩展 Object 而是会扩展 String 因为你说过。考虑以下更改：

public class Abc{

    public void doSomething(){

    }

    @Override
    public String toString(){
        return "hello";
    }

}

现在，如果您调用 toString()，您的类将始终返回“hello”。

现在想象一下下面的类：

public class Flyer{

    public void makeFly(){

    }

}

public class Bird extends Abc, Flyer{

    public void doAnotherThing(){

    }

}

同样，类 Flyer 隐式扩展了具有方法 toString() 的 Object，任何类都将具有此方法，因为它们都扩展了 Object 间接地，所以，如果您从 Bird 调用 toString()，java 必须使用哪个 toString() ？来自 Abc 还是 Flyer？任何试图扩展两个或多个类的类都会发生这种情况，为了避免这种“方法冲突”，他们构建了接口的思想，基本上你可以将它们视为抽象类它不会间接扩展 Object。由于它们是抽象，因此它们必须由一个类实现，该类是一个对象（您不能单独实例化接口，它们必须由类实现），因此一切都会继续正常进行。

为了区分类和接口，关键字 implements 仅为接口保留。

您可以在同一个类中实现您喜欢的任何接口，因为它们默认情况下不会扩展任何内容（但您可以创建一个扩展另一个接口的接口，但同样，“父亲”接口不会扩展“Object”），因此接口是只是一个接口，它们不会遭受“方法签名冲突”的影响，如果这样做，编译器会向您发出警告，您只需更改方法签名即可修复它（签名=方法名称+参数+返回类型）。

public interface Flyer{

    public void makeFly(); // <- method without implementation

}

public class Bird extends Abc implements Flyer{

    public void doAnotherThing(){

    }

    @Override
    public void makeFly(){ // <- implementation of Flyer interface

    }

    // Flyer does not have toString() method or any method from class Object, 
    // no method signature collision will happen here

}

Since this topic is not close I'll post this answer, I hope this helps someone to understand why java does not allow multiple inheritance.

Consider the following class:

public class Abc{

    public void doSomething(){

    }

}

In this case the class Abc does not extends nothing right? Not so fast, this class implicit extends the class Object, base class that allow everything work in java. Everything is an object.

If you try to use the class above you'll see that your IDE allow you to use methods like: equals(Object o), toString(), etc, but you didn't declare those methods, they came from the base class Object

You could try:

public class Abc extends String{

    public void doSomething(){

    }

}

This is fine, because your class will not implicit extends Object but will extends String because you said it. Consider the following change:

public class Abc{

    public void doSomething(){

    }

    @Override
    public String toString(){
        return "hello";
    }

}

Now your class will always return "hello" if you call toString().

Now imagine the following class:

public class Flyer{

    public void makeFly(){

    }

}

public class Bird extends Abc, Flyer{

    public void doAnotherThing(){

    }

}

Again class Flyer implicit extends Object which has the method toString(), any class will have this method since they all extends Object indirectly, so, if you call toString() from Bird, which toString() java would have to use? From Abc or Flyer? This will happen with any class that try to extends two or more classes, to avoid this kind of "method collision" they built the idea of interface, basically you could think them as an abstract class that does not extends Object indirectly. Since they are abstract they will have to be implemented by a class, which is an object (you cannot instanciate an interface alone, they must be implemented by a class), so everything will continue to work fine.

To differ classes from interfaces, the keyword implements was reserved just for interfaces.

You could implement any interface you like in the same class since they does not extends anything by default (but you could create a interface that extends another interface, but again, the "father" interface would not extends Object"), so an interface is just an interface and they will not suffer from "methods signature colissions", if they do the compiler will throw a warning to you and you will just have to change the method signature to fix it (signature = method name + params + return type).

public interface Flyer{

    public void makeFly(); // <- method without implementation

}

public class Bird extends Abc implements Flyer{

    public void doAnotherThing(){

    }

    @Override
    public void makeFly(){ // <- implementation of Flyer interface

    }

    // Flyer does not have toString() method or any method from class Object, 
    // no method signature collision will happen here

}

回复收藏 0 原文

々眼睛长脚气 2024-09-02 17:07:31

出于同样的原因，C# 不允许多重继承，但允许您实现多个接口。

从具有多重继承的 C++ 中吸取的教训是，它会导致比其价值更多的问题。

接口是您的类必须实现的事物的契约。您无法从该界面获得任何功能。继承允许您继承父类的功能（在多重继承中，这可能会变得非常混乱）。

允许多个接口允许您使用设计模式（如适配器）来解决使用多重继承可以解决的相同类型的问题，但以更可靠和可预测的方式。

回复收藏 0 原文

我的奇迹 2024-09-02 17:07:31

例如两个类 A、B 具有相同的方法 m1()。并且类 C 扩展了 A、B。

 class C extends A, B // for explaining purpose.

现在，类 C 将搜索 m1 的定义。首先，它会在班级中查找，如果没有找到，则会向家长班级查找。 A、B 都有定义所以这里出现了应该选择哪个定义的歧义。
所以JAVA不支持多重继承。

For example two class A,B having same method m1(). And class C extends both A, B.

 class C extends A, B // for explaining purpose.

Now, class C will search the definition of m1. First, it will search in class if it didn't find then it will check to parents class. Both A, B having the definition So here ambiguity occur which definition should choose.
So JAVA DOESN'T SUPPORT MULTIPLE INHERITANCE.

回复收藏 0 原文

乖乖兔^ω^ 2024-09-02 17:07:31

我们都知道，以简单的方式，我们可以继承（扩展）一个类，但我们可以实现如此多的接口..那是因为在接口中我们不给出实现，只是说功能。假设如果java可以扩展这么多类并且这些类具有相同的方法..在这一点上，如果我们尝试在子类中调用超类方法，那么应该运行什么方法？？，编译器会感到困惑
示例：- 尝试多个扩展
但在接口中，这些方法没有主体，我们应该在子类中实现它们。
尝试多种实现
所以不用担心..

回复收藏 0 原文

壹場煙雨 2024-09-02 17:07:31

由于不明确，类不支持多重继承。
（这一点在上面使用 super 关键字的答案中已经清楚地解释了）

现在对于接口，

直到 Java 7，接口都无法定义方法的实现。因此，如果类从具有相同方法签名的多个接口实现，则该方法的实现将由该类提供。
从 java 8 开始，接口也可以有方法的实现。因此，如果类实现了两个或多个具有相同方法签名和实现的接口，那么也必须在该类中实现该方法。

从 Java 9 开始，接口可以包含静态方法、私有方法、私有静态方法。

接口功能的修改（基于 java 版本 7,8,9）

回复收藏 0 原文

城歌 2024-09-02 17:07:31

因为接口只是一个契约。而类实际上是数据的容器。

回复收藏 0 原文

话少情深 2024-09-02 17:07:31

考虑一个场景，其中 Test1、Test2 和 Test3 是三个类。 Test3 类继承 Test2 和 Test1 类。如果 Test1 和 Test2 类具有相同的方法，并且您从子类对象调用它，则调用 Test1 或 Test2 类的方法会存在歧义，但接口不存在这种歧义，因为接口中没有实现。

回复收藏 0 原文

南笙 2024-09-02 17:07:31

Java 不支持多重继承、多路径和混合继承，因为存在以下歧义
问题。

多重继承的场景：让我们以类A、类B、类C为例。类A有alphabet()；方法，B类也有alphabet()；方法。现在类 C 扩展了 A、B，我们正在为子类创建对象，即类 C ，因此 C ob = new C();然后如果你想调用这些方法 ob.alphabet();哪个类方法采用？是A类方法还是B类方法？所以在JVM层面就出现了歧义问题。因此Java不支持多重继承。

多重继承

参考链接： https://plus.google.com/u/0/communities/102217496457095083679

回复收藏 0 原文

浪漫人生路 2024-09-02 17:07:31

举个例子，类 A 有一个 getSomething 方法，类 B 有一个 getSomething 方法，类 C 扩展 A 和 B。如果有人调用 C.getSomething 会发生什么？无法确定调用哪个方法。

接口基本上只是指定实现类需要包含哪些方法。实现多个接口的类仅意味着该类必须实现所有这些接口的方法。 Whci 不会导致上述任何问题。

回复收藏 0 原文

三生一梦 2024-09-02 17:07:31

该图解释了多重继承的问题。

派生类的继承成员是什么？它在派生类中仍然是私有的还是公开的？
为了在 Java 中避免出现此类问题，他们删除了多重继承。该图是面向对象编程问题的简单示例。

回复收藏 0 原文

油焖大侠 2024-09-02 17:07:31

* 这是一个简单的答案，因为我是 Java 初学者 *

考虑有三个类 X、Y 和 Z< /代码>。

所以我们像X extends Y, Z一样继承
Y 和 Z 都有一个具有相同返回类型和参数的方法 alphabet()。 Y 中的方法 alphabet() 表示显示第一个字母，而 Z 中的方法 Alphabet 表示显示最后一个字母表。
因此，当 X 调用 alphabet() 时，就会出现歧义。是否显示显示第一个或最后字母？？？
所以java不支持多重继承。
对于接口，请将 Y 和 Z 视为接口。因此两者都将包含方法 alphabet() 的声明，但不包含定义。它不会告诉是否显示第一个字母表或最后一个字母表或其他任何内容，而只是声明一个方法 alphabet()。因此没有理由提出歧义。我们可以在类 X 中使用我们想要的任何内容来定义该方法。

总之，接口定义是在实现之后完成的，因此不会造成混淆。

回复收藏 0 原文

杀手六號 2024-09-02 17:07:31

这是保持低复杂性的决定。
使用混合继承，实现起来会更加复杂，而且无论如何，多重继承也可以通过其他方式实现。

回复收藏 0 原文

为什么Java中没有多重继承，但允许实现多个接口？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（21）

关于作者

相关话题

热门标签

推荐作者

琉璃梦幻

qq_4zWU6L

话少情深

西西弗的石头怪

彻夜缠绵

千寻…

友情链接

为什么Java中没有多重继承，但允许实现多个接口？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（21）

关于作者

相关话题

热门标签

推荐作者

琉璃梦幻

qq_4zWU6L

话少情深

西西弗的石头怪

彻夜缠绵

千寻…

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。