1，继承

# class A(object):pass　　 # 父类，基类，超类
# class B:pass 　　 # 父类，基类，超类
# class A_son(A,B):pass 　　# 子类，派生类。A_son有2个父类，多继承
# class AB_son(A):pass　　 # 子类，派生类
# 一个类 可以被多个类继承
# 一个类 可以继承多个父类 —— python里
# print(A_son.__bases__)
# print(AB_son.__bases__)
# print(A.__bases__)　　 # python3 -新式类　　# 没有继承父类默认继承object

 

class Animal:
　　def __init__(self,name,aggr,hp):
　　　　self.name = name
　　　　self.aggr = aggr
　　　　self.hp = hp
　　　　self.func()
　　def func(self):
　　　　print(123)
#
class Dog(Animal):
　　def func(self):
　　　　print(456)
　　def bite(self,person):
　　　　person.hp -= self.aggr
d = Dog()

 

2，派生

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('金老板',100,500,'吉娃娃')
jin.eat()
print(jin.hp)

# 父类中没有的属性 在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
　　# 如果还想用父类的，单独调用父类的:
　　　　# 父类名.方法名 需要自己传self参数
　　　　# super().方法名 不需要自己传self
# 正常的代码中 单继承 === 减少了代码的重复
# 继承表达的是一种 子类是父类的关系

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)  # 只在新式类中有，python3中所有类都是新式类 
        self.kind = kind       # 派生属性
    def eat(self):print('dog eating')


 # super().__init__(name,aggr,hp)  == super(Animal,self).__init__(name,aggr,hp) 

 所有类都是从object继承过来的

 

3，多继承

 

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

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

d = D()
d.func()

 

 

# print(D.mro())    # 可以看到类所有经过的继承顺序

# 新式类中的继承顺序 ： 广度优先

 

 

class A(object):
    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')

b = D()
b.func()
print(B.mro())

# 新式类，继承object类的才是新式类 广度优先
# 经典类，如果你直接创建一个类在2.7中就是经典类 深度优先
# print(D.mro())
# D.mro()

# 单继承 ： 子类有的用子类 子类没有用父类
# 多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？
# 经典类中，深度优先
# 新式类中，广度优先
# python2.7 新式类和经典类共存，新式类要继承object
# python3 只有新式类，默认继承object
# 经典类和新式类还有一个区别， mro方法只在新式类中存在
# super，只在python3中存在
# super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的