为什么 Java 或 C# 中不允许多重继承？

Question

我知道Java和C#中不允许多重继承。 很多书只是说，不允许多重继承。 但可以通过接口来实现。 没有讨论为什么不允许这样做。 有人能准确地告诉我为什么不允许吗？

Answer 1

简短的答案是：因为语言设计者决定不这样做。

基本上，.NET 和 Java 设计者似乎都不允许多重继承，因为他们认为添加 MI 给语言增加了太多复杂性，而提供的好处太少。

为了获得更有趣和更深入的阅读，网上有一些文章对一些语言设计者进行了采访。 例如，对于 .NET，Chris Brumme（曾在 MS 从事 CLR 工作）解释了他们决定不这样做的原因：

1. 不同的语言对于 MI 的实现方式实际上有不同的期望
   作品。 例如，冲突是如何发生的
   已解决以及是否重复碱基
   合并或冗余。 在我们可以之前
   在CLR中实现MI，我们要做的
   对所有语言的调查，图
   找出共同的概念，并决定
   如何将它们表达为
   语言中立的方式。 我们也会
   必须决定 MI 是否属于
   CLS 以及这意味着什么
   不需要这个概念的语言
   （例如，大概是 VB.NET）。 的
   当然，这就是我们的业务
   作为公共语言运行时，但我们
   还没时间为 MI 做这件事
   还没有。

2. 真正适合 MI 的地方其实很多
   小的。 在许多情况下，多个
   接口继承可以得到这份工作
   完成了。 在其他情况下，您可以
   能够使用封装和
   代表团。 如果我们要添加一个
   构造略有不同，例如
   mixins，那实际上会更多吗
   强大吗？

3. 多重实现继承给应用程序注入了很多复杂性。
   执行。 这种复杂性
   影响选角、布局、调度、
   现场访问、序列化、身份
   比较、可验证性、
   反射、泛型以及可能
   还有很多其他地方。

您可以在此处阅读全文。

对于 Java，您可以阅读这篇文章：

省略多个的原因
从Java语言继承
大多源于“简单、对象
导向的、熟悉的”目标。
简单语言，Java 的创造者
想要一种大多数开发人员都喜欢的语言
无需广泛掌握即可掌握
训练。 为此，他们努力
使该语言与 C++ 类似
可能（熟悉）无需携带
克服 C++ 不必要的复杂性
（简单的）。

在设计师看来，多个
继承会带来更多问题
比它解决的混乱。 所以他们砍了
来自语言的多重继承
（就像他们削减运营商
超载）。 设计师的广泛
C++ 经验告诉他们
多重继承根本不值得
头痛。

Answer 2

实现的多重继承是不允许的。

问题是，如果您有一个 Cowboy 和一个 Artist 类（两者都具有 draw() 方法的实现），然后您尝试创建一个新的 CowboyArtist 类型，则编译器/运行时无法弄清楚该怎么做。 当你调用draw()方法时会发生什么？ 有人死在街上，还是你有一幅可爱的水彩画？

我相信这被称为双钻石继承问题。

Answer 3

原因：
Java 因其简单性而非常流行且易于编码。

因此，对于程序员来说，Java 开发人员感到难以理解和复杂的东西，他们会尽力避免。 其中一种属性是多重继承。

1. 他们避免了指针
2. 他们避免了多重继承。

多重继承问题：钻石问题。

示例：

1. 假设类 A 有一个方法 fun()。 类 B 和类 C 派生自类 A。
2. 并且类 B 和 C 都重写了方法 fun()。
3. 现在假设类 D 继承了类 B 和 C。（只是假设）
4. 为类 D 创建对象。
5. D d = new D();
6. 并尝试访问 d.fun(); => 它会调用B类的fun()还是C类的fun()？

这就是钻石问题中存在的模糊性。

解决这个问题并非不可能，但它会给程序员在阅读时带来更多的混乱和复杂性。
它导致的问题比它试图解决的问题还要多。

注意：但是无论如何，您总是可以通过使用接口间接实现多重继承。

Answer 4

因为Java与C++的设计理念有很大不同。 （我不打算在这里讨论 C#。）

在设计 C++ 时，Stroustrup 希望包含有用的功能，无论它们如何被滥用。 多重继承、运算符重载、模板和各种其他功能可能会搞砸，但也有可能用它们做一些非常好的事情。

Java 的设计理念是强调语言构造的安全性。 结果是，有些事情做起来要困难得多，但您可以更加确信您正在查看的代码意味着您认为它的作用。

此外，Java 在很大程度上是对最著名的 OO 语言 C++ 和 Smalltalk 的反应。 还有许多其他 OO 语言（Common Lisp 实际上是第一个标准化的语言），它们具有可以更好地处理 MI 的不同 OO 系统。

更不用说完全可以在 Java 中使用接口、组合和委托来进行 MI。 它比 C++ 更明确，因此使用起来更笨拙，但会给你带来乍一看更容易理解的东西。

这里没有正确的答案。 有不同的答案，对于特定情况，哪一个更好取决于应用和个人偏好。

Answer 5

人们远离 MI 的主要原因（尽管绝不是唯一）是所谓的“钻石问题”，导致实施中的模糊性。 这篇维基百科文章讨论并解释得比我更好。 MI 还可能导致更复杂的代码，许多 OO 设计者声称您不需要 MI，如果您确实使用它，您的模型可能是错误的。 我不确定我是否同意最后一点，但保持简单总是一个好的计划。

Answer 6

在 C++ 中，如果使用不当，多重继承会是一个令人头疼的问题。 为了避免这些流行的设计问题，在现代语言（java、C#）中强制使用多个接口“继承”。

Answer 7

多重继承很难

• 理解，
• 很难调试（例如，如果您混合来自多个框架的类，这些框架在内部具有相同名称的方法，则可能会出现意想不到的协同作用），
• 很容易误用，
• 但实际上并不是这样的。有用
• 但难以实现，特别是如果您希望它正确且高效地完成，

因此，不将多重继承包含到 Java 语言中可以被认为是明智的选择。

Answer 8

另一个原因是单继承使得转换变得微不足道，不发出汇编程序指令（除了在需要时检查类型的兼容性之外）。 如果您有多重继承，您需要弄清楚某个父类在子类中的哪个位置开始。 因此，性能当然是一项福利（尽管不是唯一的）。

Answer 9

回到过去（70 年代），当时计算机科学更加科学，大规模生产较少，程序员有时间思考良好的设计和良好的实现，因此产品（程序）具有高质量（例如 TCP/IP 设计）和实施）。
如今，当每个人都在编程，并且经理们在截止日期之前更改规范时，像 Steve Haigh 帖子中的维基百科链接中描述的那样的微妙问题很难跟踪； 因此，“多重继承”受到编译器设计的限制。 如果您喜欢，您仍然可以使用 C++ .... 并拥有您想要的所有自由:)

Answer 10

我对“Java 中不允许多重继承”的说法持保留态度。

当一个“类型”继承多个“类型”时，就定义了多重继承。 接口也被归类为类型，因为它们具有行为。 所以Java确实有多重继承。 只是这样更安全。

Answer 11

类的动态加载使得多重继承的实现变得困难。

在java中，实际上他们通过使用单继承和接口来避免多重继承的复杂性。
在如下情况下，多重继承的复杂性非常高

多重继承的钻石问题。
我们有两个类 B 和 C 继承自 A。假设 B 和 C 重写继承的方法并且它们提供自己的实现。 现在 D 从 B 和 C 继承，进行多重继承。 D应该继承那个重写的方法，jvm无法决定使用哪个重写的方法？

在c++中，虚函数是用来处理的，我们必须显式地做。

这可以通过使用接口来避免，没有方法体。 接口无法实例化，只能由类实现或由其他接口扩展。

Answer 12

实际上，如果继承的类具有相同的功能，多重继承就会产生复杂性。 即编译器会感到困惑，必须选择哪一个（钻石问题）。 因此，在 Java 中，复杂性被消除，并提供了接口来获得像多重继承一样的功能。 我们可以使用接口

Answer 13

Java有一个概念，即多态性。 java中有两种类型的多态性。 有方法重载和方法重写。 其中，方法重写发生在超类和子类关系中。 如果我们创建一个子类的对象并调用超类的方法，并且如果子类扩展了多个类，那么应该调用哪个超类方法？

或者，当通过 super() 调用超类构造函数时，将调用哪个超类构造函数？

对于当前的 java API 功能来说，这个决定是不可能的。 所以java中不允许多重继承。

Answer 14

Java中直接不允许多重继承，但通过接口允许多重继承。

原因：

多重继承：引入更多复杂性和歧义。

接口：接口是 Java 中完全抽象的类，它为您提供了一种统一的方法，可以根据其公开可用的接口正确描述程序的结构或内部工作方式，从而获得更大的灵活性和灵活性。可重用的代码以及对如何创建其他类以及如何与其他类交互的更多控制。

更准确地说，它们是 Java 中的一种特殊构造，具有允许您执行一种多重继承的附加特性，即可以向上转换为多个类的类。

让我们举个简单的例子。

1. 假设有两个超类 A 和 B，它们的方法名称相同，但功能不同。 通过以下带有 (extends) 关键字的代码，多重继承是不可能的。

   公共类A                                
          { 
            无效显示() 
              { 
                System.out.println("你好'A'"); 
              } 
          } 
   
        公开B级                                
           { 
             无效显示() 
               { 
                 System.out.println("你好'B'"); 
               } 
           } 
   
       public class C extends A, B // 这在java中是不可能的 
         { 
           公共静态无效主（字符串参数[]） 
             { 
               C 对象 = new C(); 
               对象.display();   // 这里存在混淆，调用哪个display()，A类还是B类的方法 
             } 
         } 
     

2. 但是通过接口，使用（implements）关键字多重继承是可能的。

   接口A 
         { 
            // 展示（） 
         } 
   
   
      接口B 
         { 
           //展示（） 
         } 
   
      C类实现A、B 
         { 
            //主要的（） 
            C 对象 = new C(); 
            (A)object.display();   //调用A的显示 
   
            (B)对象.display();   //调用B的显示 
         } 
     } 
     

Answer 15

在 C++ 中，一个类可以（直接或间接）继承多个类，这称为
多重继承。

然而，C# 和 Java 将类限制为每个类继承的单一继承
来自单亲班级。

多重继承是创建结合两个不同类的各个方面的类的有用方法
层次结构，在单个类中使用不同的类框架时经常发生的情况
应用。

例如，如果两个框架定义了自己的异常基类，您可以
使用多重继承来创建可与任一框架一起使用的异常类。

多重继承的问题是它可能导致歧义。 经典的例子是当
一个类继承自另外两个类，每个类都继承自同一个类：

class A {
    protected:
    bool flag;
};
class B : public A {};
class C : public A {};
class D : public B, public C {
    public:
    void setFlag( bool nflag ){
        flag = nflag; // ambiguous
    }
};

在此示例中，flag 数据成员由class A 定义。 但是D类是B类的后代
和class C，它们都派生自A，因此本质上flag的两个副本可用，因为两个
A 的实例位于 D 的类层次结构中。 您想设置哪一项？ 编译器会抱怨
D 中对 flag 的引用不明确。 一种修复方法是显式消除引用的歧义：

B::flag = nflag;

另一种修复方法是将 B 和 C 声明为虚拟基类，这意味着只有 A 的一个副本可以
存在于层次结构中，消除了任何歧义。

多重继承还存在其他复杂性，例如基类的顺序
在构造派生对象时初始化，或者成员可能被无意隐藏的方式
来自派生类。 为了避免这些复杂性，某些语言将自己限制为更简单的单继承模型。

虽然这确实大大简化了继承，但也限制了它的用处
因为只有具有共同祖先的类才能共享行为。 接口可以缓解这种情况
通过允许不同层次结构中的类公开公共接口来稍微限制
如果它们不是通过共享代码实现的。

Answer 16

有人能准确地告诉我为什么不允许吗？

您可以从此文档链接找到答案

Java 编程语言不允许扩展多个类的原因之一是为了避免状态多重继承的问题，即从多个类继承字段的能力

如果允许多重继承并且当您通过以下方式创建对象时实例化该类时，该对象将从该类的所有超类继承字段。 这会导致两个问题。

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

2. 哪个方法或构造函数将优先？

即使现在允许状态的多重继承，您仍然可以实现

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

实现的多重继承（通过接口中的默认方法）：能够从多个类继承方法定义，

请参阅此相关的 SE 问题以获取更多信息：

接口的多重继承歧义

Answer 17

想象一下这个例子：
我有一个类 Shape1

它有 CalcualteArea 方法：

Class Shape1
{

 public void CalculateArea()

     {
       //
     }
}

还有另一个类 Shape2 也有相同的方法

Class Shape2
{

 public void CalculateArea()

     {

     }
}

现在我有一个子类 Circle，它源自 Shape1 和 Shape2；

public class Circle: Shape1, Shape2
{
}

现在，当我为 Circle 创建对象并调用该方法时，系统不知道要调用哪个计算面积方法。 两者都有相同的签名。 所以编译器会感到困惑。 这就是不允许多重继承的原因。

但可以有多个接口，因为接口没有方法定义。 即使两个接口都有相同的方法，它们都没有任何实现，并且总是会执行子类中的方法。