精华内容
下载资源
问答
  • 多重继承

    2019-09-20 19:30:57
    多重继承优点: 简单,清晰,更有利于复用。 多重继承缺点: 1)可能会产生菱形继承,存在二义性问题。 菱形继承 假如类B是从A1和A2两个类多重继承而来的,而A1和A2又有个共同的基类Base,那这样B类就包含了两...

    多重继承优点:

                   简单,清晰,更有利于复用。

    多重继承缺点:

    1)可能会产生菱形继承,存在二义性问题。

    菱形继承

    假如类B是从A1和A2两个类多重继承而来的,而A1和A2又有个共同的基类Base,那这样B类就包含了两个Base成员,这样就不但增加了存储空间,同时也引入了二义性,我调用Base里面的一个普通成员函数,我的this指针到底应该传哪一个Base呢?这时候就会直接出错。(解决方法虚拟继承)

     

    菱形继承关系

    我们C++语言来描述这种继承关系:

    class Base{… … };

    class A1 :public Base {… … };

    class A2 :public Base {… … };

    class B :public A1,public A2 {… … };

    2)多重继承带来性能上的损失

    当使用第一继承的基类指针来调用派生类的虚函数的时候,与单继承的情况没有什么异样,而如果以第二或后继的基类指针(或引用)的指向派生类的时候,需要把this指针调整回派生类对象的起始点,而这个偏移量是存放在虚函数表里面的,这样就多了一层内存的读取。

    结论:

    不要随意使用多重继承。大多数的情况,用has a(也就是类的组合法)会更好些。

    展开全文
  • C++ 多重继承

    2021-01-20 13:39:42
    注意:多重继承在实际开发中尽量少用,能不用就不用。多重继承很繁杂,很复杂。 多重继承就是派生类继承多个基类,继承方法和一个继承是一样的。 一个继承请看我 —> “C++ 继承和派生” 文章,会有详细介绍。 链接:...
  • 主要介绍了java为什么不允许类多重继承却允许接口多重继承,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 本文以实例形式较为全面的讲述了C++的多重继承与虚继承,是大家深入学习C++面向对象程序设计所必须要掌握的知识点,具体内容如下: 一、多重继承 我们知道,在单继承中,派生类的对象中包含了基类部分 和 派生类...
  • 在本篇文章中我们给大家分析了python继承与多重继承的相关知识点内容,有兴趣的读者们参考下。
  • 说说C++多重继承

    2021-01-20 03:40:35
     多重继承是从多于一个直接基类派生类的能力,多重继承的派生类继承其父类的属性。  class ZooAnimal{  };  class Bear : public ZooAnimal{  };  class Endangered{  };  class Panda : public ...
  • python 继承多重继承

    2017-08-17 00:15:32
    python 继承多重继承

    十七、python 继承多重继承

    继承

    1、根据已有的类生产新的类

    继承的目的:代码重用;多态

    2、多重继承

    菱形继承的问题

    经典类:深度优先

    新式类:广度优先

    Inspect.getmro(class)

     

    ---------------------------------------------------

    如下体现新式类的广度优先:即寻找顺序是: 类B---> C ----> A如下代码输出:cc

    class A(object):
        def a(self):
            print 'aa'
    class B(A):
        pass
        
    # def a(self):
        #     print 'bb'
    class C(A):
        def a(self):
            print 'cc'
    class E(B,C):
        pass
    e = E()
    e.a()

    如下体现经典类的深度优先:即寻找顺序是: 类B---> A ----> C如下代码输出:aa

    class A():
        def a(self):
            print 'aa'
    class B(A):
        pass
        
    # def a(self):
        #     print 'bb'
    class C(A):
        def a(self):
            print 'cc'
    class E(B,C):
        pass
    e = E()
    e.a()

    ---------------------------------------------------


    ------------------------------------------------

     

    class A(object):

        def __init__(self):

            print 'in A'

     

    class B(A):

        pass

     

    b = B()

     

    class C(A):

        print 'in c'

    c = C()

     

    class D(A):

        def __init__(self):

            A.__init__(self)

            print 'in d'

    d = D()

     

    #----------------------------------------

    class E:

        print 'in E0000'

        def __init__(self):

            print 'in E'

     

    class F:

        print 'in F0000'

        def __init__(self):

            print 'in F'

     

    class G(F,E):  #交换两个被继承类的位置,你在看看??当两个类中有相同方法时又是调用那个??

        print 'in G'

     

    g = G()

     

    print  '---------------------------'

    class M(A):

        def __init__(self):

            #A.__init__(self)

            super(M, self).__init__()

            print 'in M'

     

    class N(A):

        def __init__(self):

            #A.__init__(self)

            super(N,self).__init__()

            print 'in N'

     

    class P(M,N):   #发现A被初始化两次??有问题,怎么解决,用super调用

        def __init__(self):

            #M.__init__(self)

            #N.__init__(self)

            super(P,self).__init__() #使用super关键字,A就只被初始化一次。super关键字是新式类中有的,建议使用

            print 'in P'

    p = P()

     

    #使用交互式

    import inspect

    inspect.getmro(P)

    #(<class '__main__.P'>, <class '__main__.M'>, <class '__main__.N'>, <class '__main__.A'>, <type 'object'>)

    #A改成经典类,然后再把super注释,因为super是新式类的

    inspect.getmro(P)

    #(<class __main__.P at 0x00000000026CCA68>, <class __main__.M at 0x00000000026CCD08>, <class __main__.A at 0x00000000026CCDC8>, <class __main__.N at 0x00000000026CCA08>)

    ---------------------------------------------

     

     

    注:

    super(子类名字,self):self放在后面,需要和属性方法分开

    展开全文
  • java可以多重继承吗 有时我写了几篇有关Java继承,接口和组成的文章。 在这篇文章中,我们将研究多重继承,然后了解组成优于继承的好处。 Java中的多重继承 多重继承是创建具有多个超类的单个类的能力。 与其他一些...
    java可以多重继承吗

    java可以多重继承吗

    有时我写了几篇有关Java继承接口组成的文章。 在这篇文章中,我们将研究多重继承,然后了解组成优于继承的好处。

    Java中的多重继承

    多重继承是创建具有多个超类的单个类的能力。 与其他一些流行的面向对象的编程语言(例如C ++)不同, java不提供对类中多重继承的支持。 Java不支持类中的多重继承,因为它可能导致钻石问题,而不是提供一些复杂的方法来解决它,而是有更好的方法来实现与多重继承相同的结果。

    钻石问题

    为了轻松理解钻石问题,我们假定Java中支持多重继承。 在这种情况下,我们可以像下面的图像那样有一个类层次结构。

    钻石问题多重继承

    假设SuperClass是一个抽象类,声明了一些方法,而ClassA,ClassB是具体类。

    超类.java

    package com.journaldev.inheritance;
    
    public abstract class SuperClass {
    
    	public abstract void doSomething();
    }

    ClassA.java

    package com.journaldev.inheritance;
    
    public class ClassA extends SuperClass{
    
    	@Override
    	public void doSomething(){
    		System.out.println("doSomething implementation of A");
    	}
    
    	//ClassA own method
    	public void methodA(){
    
    	}
    }

    ClassB.java

    package com.journaldev.inheritance;
    
    public class ClassB extends SuperClass{
    
    	@Override
    	public void doSomething(){
    		System.out.println("doSomething implementation of B");
    	}
    
    	//ClassB specific method
    	public void methodB(){
    
    	}
    }

    现在,让我们说ClassC的实现如下所示,它扩展了ClassA和ClassB。

    ClassC.java

    package com.journaldev.inheritance;
    
    public class ClassC extends ClassA, ClassB{
    
    	public void test(){
    		//calling super class method
    		doSomething();
    	}
    
    }

    注意, test()方法正在调用超类doSomething()方法,这导致歧义,因为编译器不知道要执行哪个超类方法,并且由于菱形类图,它被称为Diamond Problem,这是Java不支持类中的多重继承的主要原因。

    请注意,具有多个类继承的上述问题也可能只出现在三个类中,它们全部具有至少一个通用方法。

    接口中的多重继承

    您可能已经注意到,我一直在说类不支持多重继承,但是接口支持多重继承,并且单个接口可以扩展多个接口,下面是一个简单的示例。

    接口A.java

    package com.journaldev.inheritance;
    
    public interface InterfaceA {
    
    	public void doSomething();
    }

    接口B.java

    package com.journaldev.inheritance;
    
    public interface InterfaceB {
    
    	public void doSomething();
    }

    注意,两个接口都声明了相同的方法,现在我们可以拥有一个扩展这两个接口的接口,如下所示。

    接口C.java

    package com.journaldev.inheritance;
    
    public interface InterfaceC extends InterfaceA, InterfaceB {
    
    	//same method is declared in InterfaceA and InterfaceB both
    	public void doSomething();
    
    }

    这样做非常好,因为接口仅声明方法,并且实际实现将由实现接口的具体类完成,因此在接口的多重继承中不存在任何歧义的可能性。

    这就是为什么Java类可以实现多重继承的原因,例如下面的示例。

    接口Impl.java

    package com.journaldev.inheritance;
    
    public class InterfacesImpl implements InterfaceA, InterfaceB, InterfaceC {
    
    	@Override
    	public void doSomething() {
    		System.out.println("doSomething implementation of concrete class");
    	}
    
    	public static void main(String[] args) {
    		InterfaceA objA = new InterfacesImpl();
    		InterfaceB objB = new InterfacesImpl();
    		InterfaceC objC = new InterfacesImpl();
    
    		//all the method calls below are going to same concrete implementation
    		objA.doSomething();
    		objB.doSomething();
    		objC.doSomething();
    	}
    
    }

    您是否注意到,每当我覆盖任何超类方法或实现任何接口方法时,我都使用@Override注释,它是三个内置的Java注释之一,并且 在覆盖任何方法时都应 始终使用覆盖注释

    救援人员组成

    因此,如果我们想在ClassC使用ClassA函数methodA()ClassB函数methodB() ,该解决方案在于使用composition ,这是ClassC的重构版本,该版本使用了composition来利用这两种类方法以及doSomething ()方法来自其中一个对象。

    ClassC.java

    package com.journaldev.inheritance;
    
    public class ClassC{
    
    	ClassA objA = new ClassA();
    	ClassB objB = new ClassB();
    
    	public void test(){
    		objA.doSomething();
    	}
    
    	public void methodA(){
    		objA.methodA();
    	}
    
    	public void methodB(){
    		objB.methodB();
    	}
    }

    组合与继承

    Java编程的最佳实践之一是“通过接口支持组合”,我们将研究一些偏爱这种方法的方面。

    1. 假设我们有一个超类和子类,如下所示:

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	public void methodC(){
      	}
      }

      ClassD.java

      package com.journaldev.inheritance;
      
      public class ClassD extends ClassC{
      
      	public int test(){
      		return 0;
      	}
      }

      上面的代码可以编译并正常工作,但是如果ClassC实现更改如下:

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	public void methodC(){
      	}
      
      	public void test(){
      	}
      }

      请注意,子类中已经存在test()方法,但返回类型有所不同,现在ClassD将无法编译,并且如果您使用的是任何IDE,它将建议您更改超类或子类中的返回类型。

      现在想象一下这样的情况:我们具有多个级别的类继承,并且超类不受我们控制,我们别无选择,只能更改我们的子类方法签名或名称以消除编译错误,我们还必须在所有方面进行更改子类方法被调用的地方,因此继承使我们的代码易碎。

      组合永远不会发生上述问题,这使其比继承更有利。

    2. 继承的另一个问题是,我们将所有超类方法公开给客户端,并且如果我们的超类设计不当且存在安全漏洞,那么即使我们在实现类时全神贯注,我们也会受到不良实现的影响。超类。组合可以帮助我们提供对超类方法的受控访问,而继承不提供对超类方法的任何控制,这也是组合优于继承的主要优势之一。
    3. 组合的另一个好处是它提供了方法调用的灵活性。 我们上ClassC实现不是最佳的,它提供了与将要调用的方法的编译时绑定,只需进行最小的更改,我们就可以使方法调用变得灵活并使其动态。

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	SuperClass obj = null;
      
      	public ClassC(SuperClass o){
      		this.obj = o;
      	}
      	public void test(){
      		obj.doSomething();
      	}
      
      	public static void main(String args[]){
      		ClassC obj1 = new ClassC(new ClassA());
      		ClassC obj2 = new ClassC(new ClassB());
      
      		obj1.test();
      		obj2.test();
      	}
      }

      上面程序的输出是:

      doSomething implementation of A
      doSomething implementation of B

      方法调用的这种灵活性在继承中不可用,并且提倡了最佳做法,即在继承方面偏向于组合。

    4. 单元测试很容易组合,因为我们知道超类中正在使用的所有方法,并且可以对其进行模拟,而在继承中,我们很大程度上依赖于超类,并且不知道将使用所有超类方法,因此我们需要要测试超类的所有方法,这是一项额外的工作,由于继承,我们不需要这样做。

    理想情况下,仅当在所有情况下父类和子类的“ is-a ”关系均成立时才应使用继承,否则我们应该继续进行组合。

    翻译自: https://www.javacodegeeks.com/2013/08/multiple-inheritance-in-java-and-composition-vs-inheritance.html

    java可以多重继承吗

    展开全文
  • 继承是面向对象编程的一个重要的方式,通过继承,子类就可以扩展父类的功能。这篇文章主要介绍了Python多重继承之菱形继承,需要的朋友可以参考下
  • python多重继承实例

    2020-12-23 19:46:57
    本文实例讲述了python多重继承用法,分享给大家供大家参考。具体实现方法如下: 1.mro.py文件如下: #!/usr/bin/python # Filename:mro.py class P1: def foo(self): print 'called P1-foo' class P2: def foo...
  • 多重继承相关

    2012-03-20 14:31:38
    多重继承,执行顺序,多重继承的规则,c++工程师面试题目之一
  • 主要介绍了python的多重继承的理解的相关资料,多重继承不是多容易理解,这里举例说明帮助大家学习参考,需要的朋友可以参考下
  • 第4章继承和多重继承.ppt
  • 尽管在理想的使用环境中,一个C++程序员并不需要了解这些编译器内部实现细节,实际上,编译器针对多重继承(特别是虚拟继承)的各种实现细节对于我们编写C++代码都或多或少产生一些影响(比如downcastingpointer、...
  • Lua多重继承代码实例

    2020-09-22 05:00:34
    主要介绍了Lua多重继承代码实例,本文直接给出实例代码,需要的朋友可以参考下
  • C++习题 多重继承

    2016-07-07 12:59:31
    c++多重继承的一个习题
  • python中多重继承 多重继承 (Multiple inheritance ) When we have one child class and more than one parent classes then it is called multiple inheritance i.e. when a child class inherits from more than ...

    python中多重继承

    多重继承 (Multiple inheritance )

    When we have one child class and more than one parent classes then it is called multiple inheritance i.e. when a child class inherits from more than one parent class.

    当我们有一个子类和一个以上的父类时,则称为多重继承,即当一个子类从多个父类继承时。

    In this program, we have two parent classes Personel and Educational and one child class named Student and implementing multiple inheritance.

    在此程序中,我们有两个父类Personnel和Educational ,一个子类名为Student并实现了多重继承

    Python代码演示多重继承的示例 (Python code to demonstrate example of multiple inheritance)

    # Python code to demonstrate example of 
    # multiple inheritance 
    
    class Personel:
        def __init__(self):
            self.__id=0
            self.__name=""
            self.__gender=""
        def setPersonel(self):
            self.__id=int(input("Enter Id: "))
            self.__name = input("Enter Name: ")
            self.__gender = input("Enter Gender: ")
        def showPersonel(self):
            print("Id: ",self.__id)
            print("Name: ",self.__name)
            print("Gender: ",self.__gender)
    
    class Educational:
        def __init__(self):
            self.__stream=""
            self.__year=""
        def setEducational(self):
            self.__stream=input("Enter Stream: ")
            self.__year = input("Enter Year: ")
        def showEducational(self):
            print("Stream: ",self.__stream)
            print("Year: ",self.__year)
    
    class Student(Personel,Educational):
        def __init__(self):
            self.__address = ""
            self.__contact = ""
        def setStudent(self):
            self.setPersonel()
            self.__address = input("Enter Address: ")
            self.__contact = input("Enter Contact: ")
            self.setEducational()
    
        def showStudent(self):
            self.showPersonel()
            print("Address: ",self.__address)
            print("Contact: ",self.__contact)
            self.showEducational()
    
    def main():
        s=Student()
        s.setStudent()
        s.showStudent()
    if __name__=="__main__":main()
    
    

    Output

    输出量

    Enter Id: 101
    Enter Name: Prem Sharma  
    Enter Gender: Male   
    Enter Address: Nehru Place, New Delhi
    Enter Contact: 0123456789
    Enter Stream: Computer Science   
    Enter Year: 2010 
    Id:  101 
    Name:  Prem Sharma   
    Gender:  Male
    Address: Nehru Place, New Delhi 
    Contact: 0123456789 
    Stream:  Computer Science
    Year:  2010
    
    
    

    翻译自: https://www.includehelp.com/python/example-of-multiple-inheritance-in-python.aspx

    python中多重继承

    展开全文
  • JS多重继承实例,js新手学习资料

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 114,305
精华内容 45,722
关键字:

多重继承