6-2面向对象的组合和继承以及多继承

一 组合概念

一个类的对象作为另外一个类对象的属性
第一个例子：

class Weapon:
    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称;
        self.weapon = Weapon()  # 给角色绑定一个武器;
        
egg = Person('egon')
egg.weapon.prick() 
#egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法

第二个例子计算圆环的面积

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi * self.r ** 2 #求园的面积
    def perimeter(self):
        return self.r *pi * 2  #求园的周长

class Ring:
    def __init__(self,outside_r,inside_r):
        self.out_circle = Circle(outside_r)
        self.in_circle = Circle(inside_r)
    def area(self):
        return self.out_circle.area() - self.in_circle.area() #外环面积-内环面积
    def perimeter(self):
        return self.out_circle.perimeter() + self.in_circle.perimeter()

r = Ring(10,5)   #外环的半径和内环的半径
print(r.area())
print(r.perimeter())

 二 继承

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

class Animal: #父类
    def __init__(self,name,dps,hp):
        self.name=name
        self.dps=dps
        self.hp=hp
    def eat(self):
        print('%s吃药,回血了'%(self.name))
class Person(Animal):#子类
    def __init__(self,name,dps,hp,sex):
        super().__init__(name,dps,hp)   #第二中写法  Animal.__init__(self,name,dps,hp)

        self.sex=sex
    def attack(self,dog):
        dog.hp -= self.dps
        print('%s打了%s,%s掉了%s点血，%s还剩%s点血'%(self.name,dog.name,dog.name,self.dps,dog.name,dog.hp))

class Dog(Animal):#子类
    def __init__(self,name,dps,hp,kind):
        super().__init__(name,dps,hp)
        self.kind=kind
    def bite(self,person):
        person.hp -= self.dps
        print('%s咬了%s,%s掉了%s点血，%s还剩%s点血' % (self.name, person.name, person.name, self.dps, person.name, person.hp))
alex=Person('alex',5,250,'男')
ha2=Dog('小黑',200,2000,'藏獒')
print(alex.__dict__)
print(ha2.__dict__)
alex.attack(ha2)
ha2.bite(alex)
ha2.eat()

例子2

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):

    def func(self):
        print('in Son')
Son() 

#打印结果是in son

实例化了一个对象，找自己方法里面的self，然后再去执行父类里面的self也就是son里面是self，然后又去调用func,所以打印in son

 三多继承

# python两种类
    # 经典类 py3已经灭绝了 在python2里还存在，在py2中只要程序员不主动继承object，这个类就是经典类   —— 深度优先
    # 新式类 python3所有的类都
钻石继承

class A:
    def f(self):
        print('in A')

class B(A):
    def f(self):
        print('in B')
        super().f()

class C(A):
    pass
    def f(self):
        print('in C')
        super().f()

class D(B,C):
    def f(self):
        print('in D')
        super().f()

d = D()
d.f()
print(D.mro()) #可以查看继承的顺序
打印结果

in D
in B
in C
in A
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

#super和找父类这件事是两回事
# 在单继承中 super就是找父类
# 在多级承中 super的轨迹 是根据整个模型的起始点而展开的一个广度优先顺序 遵循mro规则

例子2

class A:
    def f(self):
        print('in A')

class B(A):
    pass
    # def f(self):
    #     print('in B')

class C(A):
    pass
    # def f(self):
    #     print('in C')


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

class E(C):
    pass
    # def f(self):
    #     print('in B')

class F(D,E):
    pass
    # def f(self):
    #     print('in C')

# d = D()
# d.f()

print(F.mro())