day24:继承

1，复习1

# 面向对象编程
# 思想：角色的抽象，创建类，创建角色（实例化），操作这些示例
# 面向对象的关键字

class 类名:
    静态属性 = 'aaa'
    def __init__(self):pass

类名.静态属性 # --储存在类的命名空间里
对象 = 类名() # 实例化：创造了一个self对象，执行init方法，返回self对象给外部
# 对象.属性
# 对象.方法 绑定方法，方法和对象绑定到了一起 # 类名.方法（对象）
# 对象可以使用静态变量？True
# 类可以使用对象里的属性吗？False

2，复习2

# 组合
# 一个类的对象是另外一个类的属性
# 什么有什么的关系

class A:
    def __init__(self):
        self.name = 'egon'

class B:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

b = B(18,1,17)
a = A()
a.birth = b
print(b.year)  #
print(a.birth.year) #

3，面向对象的三大特性：继承，多态和封装，非常非常重要的，计算机领域的三大特性

什么是继承：继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

class A:pass # 父类，基类，超类
class B:pass # 父类，基类，超类
class A_son(A,B):pass # 子类，派生类
class AB_son(A):pass # 子类，派生类

# 一个类 可以被多个类继承
# 一个类 可以继承多个父类 ----这个只有Python里面才有

print(A_son.__bases__)
# (<class '__main__.A'>, <class '__main__.B'>)
print(AB_son.__bases__)
# (<class '__main__.A'>,)
print(A.__bases__)
# (<class 'object'>,)

4，类里面，刚开始加载类的时候，就从上到下把类里面的名字加载进去了，加载进去后才可以用类名.静态属性。占内存的也只是里面的变量名字而已

5，object在类食物链的顶端， python3里面没有继承父类，默认继承object，这种累叫做新式类，object类是一个非常强大的类，里面实现了很多很多的内容，object里面有很多双下方法

6，通常的继承都是我们自己写的类，但是到网络编程的时候，我们会接触到继承Python里面已经存在的类，例如str等

7，抽象，抽取类似或者比较像的部分，抽象最主要的作用是划分类别，可以隔离关注点，降低复杂度

8，类和类的关系叫做继承，类和对象的关系叫做实例化。

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

class Dog(Animal):
    def bite(self,person):
        person.hp -= self.aggr

class Person(Animal):
    pass

jin = Dog('bossjin',200,500)  # 子类没有__init__方法，会去调用父类的双下init方法
print(jin.name)

9，子类和父类都有的方法，会优先调用谁的呢？这是一道面试题,传谁的self就运行谁的方法。

class Animal:
    def __init__(self):
        print("执行Animal.__init__")
        self.func()

    def eat(self):
        print('%s eating'%self.name)

    def drinking(self):
        print("%s dringking"%self.name)

    def func(self):
        print("Animal.func")

class Dog(Animal):
    def guard(self):
        print('guarding')

    def func(self):
        print('Dog.func')

dog = Dog()  # 这儿调用的是Dog类里面的func.因为self传得是dog

运行结果：
执行Animal.__init__
Dog.func

10，对于下面的问题怎么解决呢？

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        self.kind = kind

    def bite(self,person):
        person.hp -= self.aggr

jin = Dog('bossjin',200,500,'teddy')
print(jin.name)  # AttributeError: 'Dog' object has no attribute 'name'
# 错误原因，自己有了init就不会再去运行父类的init方法，

11，派生属性

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp) # 这个地方我们不仅完成了继承，还完成了派生，也就是一个派生属性，新添加的属性
        self.kind = kind

    def bite(self,person):
        person.hp -= self.aggr

jin = Dog('bossjin',200,500,'teddy')
print(jin.name) # bossjin

12，除了有派生属性，还有派生方法，父类没有子类有的就是派生方法；父类中没有的属性，在子类中出现，叫做派生属性；父类中没有的方法，在子类中出现，叫做派生方法。

只要是子类的对象调用，子类中有的名字，一定用子类的，子类中没有才找父类的，如果父类也没有，报错；如果父类子类都有，用子类的；如果还想用父类的，单独调用父类的，需要自己传self参数。

13，既想实现新的功能，也想用父类的功能，需要单独调用父类的

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

    def eat(self):
        print("吃药回血")
        self.hp += 100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp) # 这个地方我们不仅完成了继承，还完成了派生，也就是一个派生属性，新添加的属性
        self.kind = kind # 派生属性

    def eat(self):
        Animal.eat(self)  # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
        self.teeth = 2

    def bite(self,person):  # 派生方法
        person.hp -= self.aggr

jin = Dog('bossjin',200,500,'teddy')
jin.eat()
print(jin.teeth)

14，另外一个调用父类方法的Python3中的用法，super，类内和类外都可以用，内部可以不传参，外部必传

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

    def eat(self):
        print("吃药回血")
        self.hp += 100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)
        # self 不需要单独传了，super()意思是找我的父类，然后就可以调用父类的init了
        # 这个地方省略了两个参数 Dog类和self对象两个参数
        # super关键字只要新式类中有，不是Python3，Python中所有的类都是新式类，Python2中两种类共存
        # super还可以再类外面用
        self.kind = kind

    def eat(self):
        Animal.eat(self)
        self.teeth = 2
        print('son class')

    def bite(self,person):
        person.hp -= self.aggr

jin = Dog('bossjin',200,500,'teddy')
jin.eat()
print(jin.teeth)
super(Dog,jin).eat() # 这儿调用的是父类的eat方法。

15，子类中调用父类方法两种：父类名.方法名 需要自己传self参数，super().方法名 类内不需要自己传self

16，正常的代码中 单继承 ==减少了代码的重复，继承表达了一种子类是父类的关系，提到组合和继承一定是两个类以上的，看是“是”的关系还是“有”的关系。例如：老师有生日，狗是动物

17，工作中用的一般都是单继承，多继承一般就是设计模式，或者面试中用到，多继承的继承顺序问题

class A:
    def func(self):print('A')
class B:
    def func(self):print('B')
class C:
    def func(self): print('C')

class D(A,B,C):
    def func(self): print('D')

# 调用顺序
print(D.mro())
# [<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]

18，钻石继承问题：

class A:
    def func(self):print('A')
class B(A):
    def func(self):print('B')
class C(A):
    def func(self): print('C')

class D(B,C):
    def func(self): print('D')

# 调用顺序
print(D.mro())
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

19，Python3里面所有的新式类都是采用广度优先的方式，漏斗，如果后面有机会找到爷爷类，那么就可以广度优先找

# 漏斗
class A:
    def func(self):print('A')
class B(A):
    def func(self):print('B')
class E:
    def func(self):print('E')
class C(E):
    def func(self): print('C')

class D(B,C):
    def func(self): print('D')

# 调用顺序
print(D.mro())
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>]

20，小乌龟问题，就是一个六边形，

# 小乌龟
class F:
    def func(self):print('F')

class A(F):
    def func(self):print('A')
class B(A):
    def func(self):print('B')
class E(F):
    def func(self):print('E')
class C(E):
    def func(self): print('C')

class D(B,C):
    def func(self): print('D')

# 调用顺序
print(D.mro())
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>]

21，get 一个算法，method resolution order mro,新式类，广度优先；经典类是深度优先（一条道走到黑，只要能到就一直走这条道，走到头就走另外一条），继承object的类才是新式类，经典类如果直接创建一个类在2.7中就是经典类，深度优先。

22，多继承中，我们子类的对象调用一个方法，默认是就近原则，经典类中，深度优先，新式类中，广度优先，python2.7新式类和经典类共存，新式类要继承object，python3中只有新式类，默认继承object，经典类和新式类有一个区别super,mro方法只在新式类中存在

23，super的本质，单继承里面永远是父类，只有多继承才会出现同级的super。

class A:
    def func(self):print('A')

class B(A):

    def func(self):
        super().func()
        print('B')

class C(A):

    def func(self):
        super().func()
        print('C')

class D(B,C):

    def func(self):
        super().func()
        print('D')

d = D()
d.func()

print(D.mro())  # [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

# A
# C
# B
# D

# super的本质，不是直接找父类，而是根据调用者的节点位置的广度优先顺序来的