继承与多继承

一, 继承

　　继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为

　　基类或超类，新建的类称为派生类或子类

　　1. python中类的继承分为：单继承和多继承

        class ParentClass1: #定义父类
            pass

        class ParentClass2: #定义父类
            pass

        class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
            pass

        class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
            pass

　　2. 查看继承

        >>> SubClass1.__bases__ #__bases__是查看所有继承的父类
        (<class '__main__.ParentClass1'>,)
        >>> SubClass2.__bases__
        (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

　　提示：如果没有指定基类，python的类会默认继承object类，object是所有python新式类类的基

　　类，它提供了一些常见方法（如__str__）的实现。

        >>> ParentClass1.__bases__
        (<class 'object'>,)
        >>> ParentClass2.__bases__
        (<class 'object'>,)

　　3. 继承的重要性

========================第一部分
        例如
   
　        　猫可以：爬树、吃

　        　狗可以：看门、吃

        如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
 

        #猫和狗有大量相同的内容
        class 猫：

            def爬树(self):
                print '爬树'

            def 吃(self):
                # do something

        class 狗：

            def 看门(self):
                print '看门'

            def 吃(self):
                # do something


========================第二部分
        上述代码不难看出，吃是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，
        如下实现：

　        　动物：吃

　　           猫：爬树（猫继承动物的功能）

　　           狗：看门（狗继承动物的功能）

        伪代码如下：
        class 动物:

            def 吃(self):
                # do something
      
        # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
        class 猫(动物)：

            def爬树(self):
                print '爬树'

        # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
        class 狗(动物)：

             def 看门(self):
                print '看门'


========================第三部分
       #继承的代码实现
        class Animal:

            def eat(self):
                print("%s 吃 " %self.name)


        class Cat(Animal):

            def __init__(self, name):
                self.name = name
                self.breed = '猫'

            def爬树(self):
                print '爬树'

        class Dog(Animal):

            def __init__(self, name):
                self.name = name
                self.breed='狗'
  
            def 看门(self):
                print '看门'


# ######### 执行 #########

        c1 = Cat('小白家的小黑猫')
        c1.eat()


        d1 = Dog('胖子家的小瘦狗')
        d1.eat()

        使用继承来重用代码比较好的例子    

 　　

　　4. 继承的好处

　　　a,提高了代码的复用性
　　　b：提高了代码的维护性
　　　c：让类与类之间产生了关系，是多态的前提

　　5. 

        class Animal:
            zhuangtai='能运动'
            qiguan='有大脑'
            def __init__(self,name,sex,age):
                self.name=name
                self.sex=sex
                self.age=age
           def food(self):
                print('不好吃')

        class Person(Animal):
            def __init__(self, name, sex, age,shenggao):
                Animal.__init__(self, name, sex, age) #用类名调用方法,调用父类中的构造方法并执行.
                #super().__init__(name,sex,age)
                self.shenggao=shenggao

            def work(self,):
                print('每天上班')


        class Dog(Animal):
           def food(self):
                super().food()     #用super关键字使父类与子类中的food方法调用                                           #法都执行,super自动把self接收到的对象传给
                           　　　　 # 父类,不用在其()内写self
                print('屎很香')


        p1=Person('李','男','20',165)
        d1=Dog('旺财','公',10)
        print(p1.zhuangtai)     #用对象调用父类
        print(Person.zhuangtai)    #用类调用父类
        print(p1.__dict__)
        d1.food()                

二, 多继承

　　1、Python的类可以继承多个类，Java和C#中则只能继承一个类

　　2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：

　　　深度优先和广度优先

 

  

•    当类是经典类时，多继承情况下，会按照深度优先方式查找
•    当类是新式类时，多继承情况下，会按照广度优先方式查找

　　3. 经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后

　　推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新

　　式类，否则便是经典类。

 

 

　　 4. 经典多继承

        class D:

            def bar(self):
                print 'D.bar'
    

        class C(D):

            def bar(self):
                print 'C.bar'


        class B(D):

            def bar(self):
                print 'B.bar'


        class A(B, C):

            def bar(self):
                print 'A.bar'
    
        a = A()
        # 执行bar方法时
        # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
        # 所以，查找顺序：A --> B --> D --> C
        # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
        a.bar()

　　 5. 新类多继承

        class D(object):

            def bar(self):
                print 'D.bar'


        class C(D):

            def bar(self):
                print 'C.bar'


        class B(D):

            def bar(self):
                print 'B.bar'


        class A(B, C):

            def bar(self):
                print 'A.bar'

        a = A()
        # 执行bar方法时
        # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
        # 所以，查找顺序：A --> B --> C --> D
        # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
        a.bar()

　　经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续

　　　去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

　　新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续

　　　去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

　　注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了