面向对象(三)

一、新式类的继承原理
二、经典类的继承原理
三、super函数
四、多态与多态性
五、封装

一、新式类的继承原理

新式类继承原则：广度优先

二、经典类的继承原理

经典类继承原则：深度优先

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #查看继承顺序，只有新式才有这个属性可以查看线性列表，经典类没有这个属性

三、super函数

子类调用父类函数通过super()

class Chinese(People): #Chinese继承People
    country='China'
    def __init__(self,name,sex,age,language='Chinese'):  
        #People.__init__(self,name,sex,age) #子类重用父类的__init__()
        super().__init__(name,sex,age) #super方法：子类重用父类的__init__()，不用self
        self.language=language

class Vehicle:  # 定义交通工具类
    Country = 'China'

    def __init__(self, name, speed, load, power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print('开动啦...')


class Subway(Vehicle):  # 地铁
    def __init__(self, name, speed, load, power, line):
        # super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
        super().__init__(name, speed, load, power)
        self.line = line

    def run(self):
        print('地铁%s号线欢迎您' % self.line)
        super(Subway, self).run()  #'Subway, self'可有可无


class Mobike(Vehicle):  # 摩拜单车
    def __init__(self, name, speed, load, power, code):
        super().__init__(name, speed, load, power)
        self.code = code
    def run(self):
        print('蹬车蹬起来')
        super().run()

line13 = Subway('中国地铁', '180m/s', '1000人/箱', '电', 13)
line13.run()

bike = Mobike('摩拜单车', '18m/s', '1人／车', '饭', '3dcode')
bike.run()

四、多态与多态性

多态：同一种事物的多种形态，哺乳动物和两栖动物都继承于动物，子类都继承于父类后，都具备父类的属性，可调用父类的绑定方法
多态性：同一种调用方式，不同的执行效果

def func(obj):
    obj.walk()
#对象都继承了动物类，都具有walk绑定方法，直接调用
func(people)
func(cat)
func(dog)

五、封装

1.封装的目的
保护隐私(对外隐藏，对内可见)和隔离复杂度

2.分装分为两种情况
第一种：创建类和对象本身就是一种封装，通过类名和对象名调用属性

第二种：将类中的属性和方法隐藏隐藏起来，只可以在类内部调用，外部无法访问该属性或者方法
python中通过__双下划线的方式实现隐藏属性,

class A:
    __x = 12  #__x在定义时就会变形：_A__x
    def __p(self):  #__p(self)在定义时就会变形：_A__p(self)
        print('from a')
a = A()
print(a.__x)
a.__p()
'''
执行结果：
AttributeError: 'A' object has no attribute '__p'
'''