核心语法--Python-Class05

核心语法-Python-Class05

类的多继承

与单继承不同的是，多继承指的是子类继承两个或多个父类。再定义多继承子类时，采用以下形式：

class 子类(父类1，父类2)：#甚至多个父类
    类体

通过以下案例对多继承进行解释说明：
众所周知，市面上的汽车主要有燃油汽车、电动汽车和混合动力汽车3类。从继承的角度来看，可将混合动力汽车理解为对燃油汽车和电动汽车的一种继承，
也就是说，混合动力汽车类继承了燃油汽车类和电动汽车类，它是一个多继承的子类。
燃油汽车：
属性：燃油种类、排量
方法：计算续航里程
电动汽车：
属性：电车种类、容量
方法：计算续航里程
混合动力汽车：燃油汽车、电动汽车

混合动力汽车既继承了父类1——燃油汽车的所有属性和方法，也继承了父类2——电动汽车的所有属性和方法
，但同时它也可以拥有自己的属性和方法。
例如：计算续航里程，这个方法肯定不同于燃油汽车，也不同于电动汽车。
显然，混合东西汽车子类是一个典型的多继承。

案例：多继承

#燃油汽车类1
class GasCar(object):
    def __init__(self,gastype,displacement,oil):
        #属性：
            # 燃油类型gastype
            # 排量displacement
            # 油量oil
        self.gastype = gastype
        self.displacement = displacement
        self.oil = oil

    #计算续航里程
    def mileage(self):
        if  self.oil > 0:
            return 100 * self.oil / 9
        else:
            return 0
    #加油
    def adjustoil(self,oilmass): #调整油量
        if oilmass > 0 and oilmass <= 60:
            oil += oilmass
            if oil > 60: #油箱加满
                oil=60
        if oilmass < 0 and oil >= 60:
            oil -= oilmass
            if oil < 0:
                oil=0

#电动汽车类2
class ElectricCar(object):
    def __init__(self,batterytypr,capacity,residual):
        #属性：
            # 电车种类batterytypr
            # 容量capacity
            # 剩余residual
        self.batterytype = batterytypr
        self.capacity = capacity
        self.residual = residual

    #计算续航里程
    def mileage2(self):
        if self.residual > 0:
            return 100 * self.residual / 25000
        else:
            return 0

    #充电
    def adjustoil(self,power):
        if residual > 0 and residual <= capacity:
            residual += power
            if residual > 60:
                residual = 60
        if residual <0 and residual >= -capacity:
            residual -= power
            if residual <0: #没电了
                residual=0

#混合动力车类3
class Hybrids(GasCar,ElectricCar):
    def __init__(self,gastype,displacement,oil,batterytype,capacity,residual):
        super().__init__(gastype,displacement,oil)  #继承父类1
        ElectricCar.__init__(self,batterytype,capacity,residual)   #继承父类2

    def endurance(self,oil,bat):
        self.oil = oil
        self.residual = bat
        return self.mileage()  + self.mileage2()

if __name__ == '__main__':
    c1=Hybrids('汽油',1.8,43,'锂铁',18400,16020)
    print('能续航：{:.1f}'.format(c1.endurance(c1.oil,c1.residual)))
    c1.oil = 55
    c1.residual = 18400
    print('能续航：{:.1f}'.format(c1.endurance(c1.oil,c1.residual)))

类的多级继承

一个孙类继承一个子类，而子类又继承父类，这种关系称为“类的多级继承”。在Python中，类可多级继承，也就是说，继承的层级不受限制。
在多级继承中，派生类将继承父类与子类的属性和方法。
举一个植物的继承关系：
父类
植物
子类
种子植物、苔藓植物、蕨类植物、藻类植物
孙类
裸子植物、被子植物

#父类定义——植物
#植物的特性和行为对于的属性和方法
class Plant(object):
    pass

#子类定义——种子植物
class Spermatohyte(Plant):
    pass

#孙类定义——裸子植物
class Gymnosperms(Spermatohyte):
    pass

类的混合继承

继承是面向对象的一个重要方式和特性，通过继承，子类可在拥有父类所有功能的基础上扩充新的功能。
**举一个动物的继承关系“
父类
动物
子类
哺乳动物、卵生动物
孙类
狗、蝙蝠、鸭子、鹦鹉

案例2：

父类
动物
子类
能飞的、能游的
孙类
蝙蝠、鹦鹉、狗、鸭子**

如果同时采用上述两种分类原则对动物进行分类，则类的层次关系将变得非常复杂，例如，仅就哺乳类而言，可归类为能游的、能飞的哺乳类等。如果继续增加分类方式，
那么类的数量会呈指数级增长。显然，这种方式是不可行的。
正确的做法应该是采用混合继承。混合继承又被称为“MIXIN”.混合继承的目的是有效地增加类的属性和功能，它的实现方式：在设计类的时候，优先考虑采用
多继承和多层次继承的组合形式，而不是采用单纯的多层次继承，即横向与纵向结合的继承。

#以纵向设计为原则设计主类
#主类以纵向设计为原则，采用多层次的继承方式，如下：
#父类——动物类
class Animal(object):
    pass
#子类——哺乳类和卵生类
class Mammal(Animal):
    pass
class Bird(Animal):
    pass
#孙类——各种动物
class Pig(Mammal):
    pass
class Bat(Mammal):
    pass
class Parrot(Bird):
    pass
class Duck(Bird):
    pass

#以横向设计为原则设计子类
#给动物类加上 Swimable and Flyable类
class Swimable(object):
    def swim(self):
        print("Swimming...")
class Flyable(object):
    def flyable(self):
        print("Flying...")

#以混合继承为原则设计孙类
#对于需要增加Swimable功能的动物，通过继承Swimable类加以实现。如Pig类，如下
class Pig(Mammal,Swimable):
    pass

class Bat(Mammal,Bird):
    pass

混合继承的优势在于，可减少类继承的层次，降低类关系的复杂度。通过混合继承一个子类可同时获得多个父类的所有功能。