Python9-继承1-day24（大年初一）

#面向对象编程：
'''
思想：角色的抽象，创建类，创建角色，
面对对象的关键字
class 类名：
    静态属性 = ‘aaa'
    def __init__(self):pass

类名.静态属性   ———存储在类的命名空间里
对象 = 类名（）   实例化：创造了一个self对象，执行init方法，返回self对象给外部
类名.方法(对象)
对象.属性
对象.方法
对象可以使用静态变量
类不可用可以使用对象的属性
组合
一个类的对象是另外一个类对象的属性

什么是继承

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

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

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

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

class A:pass
class B:pass

class A_son(A,B):pass

print(A_son.__bases__)
print(A.__bases__)


(<class '__main__.A'>, <class '__main__.B'>)
(<class 'object'>,)

class Animal:
    def __init__(self,name,aggr,hp):
        self.name =name
        self.aggr = aggr
        self.hp =hp
class Dog(Animal):
    def bite(self,persion):
        persion.hp -= self.aggr
class Person(Animal):
    pass
jin = Dog('金老板',200,500)
print(jin.name)

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 bite(self,persion):               #派生方法
        persion.hp -= self.aggr
class Person(Animal):
    def __init__(self,name,aggr,hp,sex):
        Animal.__init__(self,name,aggr,hp)
        self.sex =sex               #派生属性
        self.money = 0               #派生属性
    def attack(self,dog):
        dog.hp -= self.aggr
    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print('余额不足，请先充值')

alex = Person('alex',0.5,100,'不详')
jin = Dog('金老板',100,500,'不详')
print(jin.name)
jin.eat()
print(jin.hp)
print(alex.name)
alex = Person('alex',1,2,None)
alex.eat()
print(alex.hp)
jin.bite(alex)
print(alex.hp)

#父类中没有的属性，在子类中出现，叫做派生属性
# 父类中没有的方法，在子类中出现，叫做派生方法
# 只要是子类的对象调用，子类中有的名字，一定有子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都没有，用子类的
# 如果还想用父类的，单独调用父类的，需要自己穿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)
        self.kind =kind                     #派生属性

jin = Dog('金老板',100,500,'teddy')
print(jin.name)

super(Dog,jin).eat()

金老板
吃药回血

 # 如果还想用父类的，单独调用父类的，需要自己穿self参数

    父类名.方法名 需要自己穿self参数
    super（）.方法名  不需要自己穿参数

class F:
    def func(self):print('F')
class A(F):
    pass
    # def func(self):print('A')
class B(A):
    pass
    # def func(self):print('B')
class E(F):
    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 '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>]

# 新式类中的继承顺序：广度优先
# 经典类  如果你直接创建一个类在2.7中就是经典类，深度优先
# 多集成中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是：
# 经典类中  深度优先
# 新式类中，广度优先
# python2.7 新式类和经典类共存，新式类要继承object
# python3  只有新式类，默认继承object
# 经典类和新式类还有个区别 super mro方法只在新式类中存在

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

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')
d = D()
d.func()

A
C
B
D