为什么Java或C语言中不允许多重继承?

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

基本上,似乎.NET和Java设计器都不允许多重继承,因为他们推断增加MI。 增加了太多的复杂性 在提供 利益太少 .

为了更有趣和深入的阅读,有一些文章可以在网络上访问一些语言设计师。例如,对于.NET,Chris Brumme(在CLR的MS工作)已经解释了为什么他们决定不:

1. 不同的语言对mi 作品。例如,冲突是如何发生的 已解决,是否存在重复碱基 合并或冗余。在我们之前 在clr中实现mi,我们必须这样做 所有语言的调查,图 说出共同的概念,然后决定 如何用 语言中立的态度。我们也会 必须决定我是否属于 CLS和这意味着什么 不需要这个概念的语言 (例如,大概是vb.net)。的 当然,这就是我们的业务 作为公共语言运行库,但是我们 还没来得及为我做呢 然而。

2. 实际上,MI真正适合的地方数量相当多 小的。在许多情况下,多个 接口继承可以获取作业 代替了。在其他情况下,您可以 能够使用封装和 代表团。如果我们要添加 结构稍有不同,比如 混血儿,那真的是更多吗? 强大?

3. 多个实现继承给 实施。这种复杂性 影响铸造、布局、调度, 字段访问、序列化、标识 比较、可验证性, 反思、仿制药,或许 很多其他地方。

You can read the full article here.

对于Java,您可以读取 this article :

省略复数的原因 Java语言的继承 主要来源于“简单,物体 有针对性,熟悉“目标。作为一个 简单的语言,Java的创造者 想要一种大多数开发人员都能使用的语言 没有广泛的掌握 培训。为此,他们努力 使语言与C++类似 可能(熟悉)不携带 超越C++的不必要复杂性 (简单)。

在设计师看来,多重 继承会导致更多的问题和 比它解决的还要混乱。所以他们切 语言的多重继承 (就像他们切割操作员一样 超载)。设计师的广泛 C++经验告诉他们 多重继承根本不值得 头痛。

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

问题是,如果您有一个牛仔类和一个艺术家类(都带有draw()方法的实现),编译器/运行时无法确定要做什么,然后尝试创建一个新的牛仔艺术家类型。调用draw()方法时会发生什么?是有人躺在街上死了,还是你有一幅可爱的水彩画?

我相信这就是所谓的双钻石继承问题。

原因: Java由于其简单性而广受欢迎且易于编码。

因此,对于程序员来说,Java程序员觉得难以理解和复杂,他们试图避免它。一种这样的属性是多重继承。

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

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

例子 :

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

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

解决这个问题并不是不可能的,但它在阅读时会给程序员带来更多的困惑和复杂性。 它引起的问题比它试图解决的问题要多。

注释 :但是任何方法都可以通过使用接口间接实现多个继承。

因为Java与C++有着截然不同的设计理念。(我不想在这里讨论C。)

在设计C++时,Stroustrup希望包括有用的特性,而不管它们如何被滥用。通过多重继承、运算符重载、模板和各种其他特性,可能会使时间过多,但也可能对它们做一些非常好的事情。

Java的设计理念是强调语言结构的安全性。结果是,有些事情做起来更尴尬,但是你可以更加自信,你看到的代码意味着你认为它能做什么。

此外,Java在很大程度上是来自C++和SimultTalk的反应,它是最著名的面向对象语言。有很多其他的OO语言(公共的Lisp实际上是第一个被标准化的语言),使用不同的OO系统更好地处理MI。

更不用说,完全可以在Java中使用接口、组合和委派来实现MI。它比C++更明确,因此使用起来笨拙,但会让你在乍一看中更容易理解。

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

人们避开MI的主要原因(尽管并非唯一原因)是所谓的“菱形问题”,这会导致实现中的模糊性。这个 wikipedia article 讨论它,比我能解释的更好。MI还可以导致更复杂的代码,许多OO设计师声称您不需要MI,如果使用它,您的模型可能是错误的。我不确定我是否同意最后一点,但保持简单总是一个好计划。

在C++中,多重继承是使用不当时的一大难题。为了避免这些流行的设计问题,多个接口“继承”被迫用现代语言(Java,C语言)代替。

多重继承是

• 很难理解
• 很难调试(例如,如果将具有相同命名方法的多个框架中的类深度混合在一起,则会发生非常意外的协同作用)
• 易误用
• 不是真的 那个 有用的
• 很难实现,特别是如果你想正确地完成它 和 有效地

因此,选择 不 在Java语言中包含多继承。

另一个原因是单一继承使得强制转换变得简单,不发出汇编程序指令(除了在需要时检查类型的兼容性)。如果您有多个继承,那么您需要确定某个父类在子类中的起始位置。因此,绩效当然是一种额外福利(尽管不是唯一的福利)。

在过去的年代(70年代),当计算机科学更为科学,批量生产更少时,程序员有时间考虑好的设计和良好的实现,因此产品(程序)具有高质量(如TCP/IP设计和实现)。 如今,当每个人都在编程,管理者在截止日期前更改规范时,很难跟踪诸如steve haigh post的wikipedia链接中描述的微妙问题;因此,“多重继承”受到编译器设计的限制。如果你喜欢它,你仍然可以使用C++…拥有你想要的所有自由:)

我接受了“Java中不允许使用多重继承”的说法。

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

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

实际上,在Java中,它们避免了多重继承的复杂性,而不是使用单个继承和接口。 在下面解释的情况下,多重继承的复杂性非常高

多重继承的菱形问题。 我们有两个从A继承的类B和C。假设B和C正在重写继承的方法,它们提供自己的实现。现在D从B和C继承,执行多重继承。d应该继承被重写的方法,JVM不能决定将使用哪个被重写的方法?

在C++中,虚拟函数是用来处理的,我们必须显式地进行。

这可以通过使用接口来避免,因为没有方法体。接口不能被实例化,它们只能由类实现或由其他接口扩展。

实际上,如果继承的类具有相同的函数,那么多个继承将产生一个复杂性。也就是说,编译器会有一个混乱的选择(钻石问题)。因此,在Java中,复杂性被移除,并给予接口以获得多继承的功能。我们可以使用接口

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

或者,在通过调用超类构造函数时 super() ,将调用哪个超类构造函数?

目前Java API的特点是不可能的。因此Java中不允许使用多重继承。

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

原因:

多重继承: 引入更多的复杂性和模糊性。

接口: 接口是Java中完全抽象的类,它为您提供了一个统一的方法来从程序的公共可用接口中适当地勾画程序的结构或内部工作,其结果是更大的灵活性和可重用代码,以及对如何创建和与其他类进行交互的更多控制。

更确切地说,它们是Java中的一种特殊构造,具有额外的特性,允许您执行一种多重继承,即可以向多个类上攻的类。

让我们举个简单的例子。

1. 假设有两个超类,A类和B类具有相同的方法名,但功能不同。通过以下带有(扩展)关键字的代码,不可能进行多重继承。

      public class A                               
        {
          void display()
            {
              System.out.println("Hello 'A' ");
            }
        }
   
      public class B                               
         {
           void display()
             {
               System.out.println("Hello 'B' ");
             }
         }
   
     public class C extends A, B    // which is not possible in java
       {
         public static void main(String args[])
           {
             C object = new C();
             object.display();  // Here there is confusion,which display() to call, method from A class or B class
           }
       }
   

2. 但是,通过接口,可以使用(实现)关键字多重继承。

   interface A
       {
          // display()
       }
   
   
    interface B
       {
         //display()
       }
   
    class C implements A,B
       {
          //main()
          C object = new C();
          (A)object.display();     // call A's display
   
          (B)object.display(); //call B's display
       }
   }
   

有人能告诉我为什么不允许这样做吗?

您可以从本文档中找到答案 link

Java编程语言不允许您扩展多个类的一个原因是避免多继承状态的问题,即继承来自多个类的字段的能力。

如果允许多重继承,并且通过实例化该类创建对象时,该对象将继承该类所有超级类的字段。这将导致两个问题。

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

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

尽管现在允许多个状态继承,但是您仍然可以实现

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

实现的多重继承 (通过接口中的默认方法):从多个类继承方法定义的能力

有关更多信息,请参阅此相关SE问题:

Multiple Inheritance Ambiguity with Interface

在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 . 但是 class D 从下降 class B 和 class C ,两者都源自 A 所以本质上 两份 属于 旗帜 因为有两个 实例 一 在 D _s类层次结构。你想设置哪一个?编译器会抱怨 指的是 旗帜 在里面 D 是 模棱两可的 . 一个解决方法是显式消除引用的歧义:

B::flag = nflag;

另一个解决方法是将b和c声明为 virtual base classes 也就是说只有一份罐头 存在于层次结构中,消除任何歧义。

其他复杂的情况存在于多重继承中,例如基类的顺序 在构造派生对象或无意中隐藏成员的方式时初始化 从派生类。为了避免这些复杂性,一些语言将自己局限于更简单的单继承模型。

虽然这确实大大简化了继承,但也限制了它的实用性。 因为只有具有共同祖先的类才能共享行为。接口减轻了这一点 通过允许不同层次结构中的类公开公共接口甚至 如果它们不通过共享代码实现。

想象一下这个例子: 我有一节课 Shape1

它有 CalcualteArea 方法:

Class Shape1
{

 public void CalculateArea()

     {
       //
     }
}

还有一个班 Shape2 那个也有同样的方法

Class Shape2
{

 public void CalculateArea()

     {

     }
}

现在我有了一个儿童类的圆,它既来源于shape1又来源于shape2;

public class Circle: Shape1, Shape2
{
}

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

但是可以有多个接口,因为接口没有方法定义。即使这两个接口都有相同的方法,它们都没有任何实现,子类中的always方法也将被执行。