#面向对象编程：
'''
思想：角色的抽象，创建类，创建角色，
面对对象的关键字
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