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

一 组合概念

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

 2 class Weapon:
 3     def prick(self, obj):  # 这是该装备的主动技能,扎死对方
 4         obj.life_value -= 500  # 假设攻击力是500
 5 
 6 class Person:  # 定义一个人类
 7     role = 'person'  # 人的角色属性都是人
 8 
 9     def __init__(self, name):
10         self.name = name  # 每一个角色都有自己的昵称;
11         self.weapon = Weapon()  # 给角色绑定一个武器;
12         
13 egg = Person('egon')
14 egg.weapon.prick() 
15 #egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法

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

 1 from math import pi
 2 class Circle:
 3     def __init__(self,r):
 4         self.r = r
 5     def area(self):
 6         return pi * self.r ** 2 #求园的面积
 7     def perimeter(self):
 8         return self.r *pi * 2  #求园的周长
 9 
10 class Ring:
11     def __init__(self,outside_r,inside_r):
12         self.out_circle = Circle(outside_r)
13         self.in_circle = Circle(inside_r)
14     def area(self):
15         return self.out_circle.area() - self.in_circle.area() #外环面积-内环面积
16     def perimeter(self):
17         return self.out_circle.perimeter() + self.in_circle.perimeter()
18 
19 r = Ring(10,5)   #外环的半径和内环的半径
20 print(r.area())
21 print(r.perimeter())

 二 继承

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

 1 class Animal: #父类
 2     def __init__(self,name,dps,hp):
 3         self.name=name
 4         self.dps=dps
 5         self.hp=hp
 6     def eat(self):
 7         print('%s吃药,回血了'%(self.name))
 8 class Person(Animal):#子类
 9     def __init__(self,name,dps,hp,sex):
10         super().__init__(name,dps,hp)   #第二中写法  Animal.__init__(self,name,dps,hp)
11 
12         self.sex=sex
13     def attack(self,dog):
14         dog.hp -= self.dps
15         print('%s打了%s,%s掉了%s点血，%s还剩%s点血'%(self.name,dog.name,dog.name,self.dps,dog.name,dog.hp))
16 
17 class Dog(Animal):#子类
18     def __init__(self,name,dps,hp,kind):
19         super().__init__(name,dps,hp)
20         self.kind=kind
21     def bite(self,person):
22         person.hp -= self.dps
23         print('%s咬了%s,%s掉了%s点血，%s还剩%s点血' % (self.name, person.name, person.name, self.dps, person.name, person.hp))
24 alex=Person('alex',5,250,'男')
25 ha2=Dog('小黑',200,2000,'藏獒')
26 print(alex.__dict__)
27 print(ha2.__dict__)
28 alex.attack(ha2)
29 ha2.bite(alex)
30 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所有的类都
钻石继承

 1 class A:
 2     def f(self):
 3         print('in A')
 4 
 5 class B(A):
 6     def f(self):
 7         print('in B')
 8         super().f()
 9 
10 class C(A):
11     pass
12     def f(self):
13         print('in C')
14         super().f()
15 
16 class D(B,C):
17     def f(self):
18         print('in D')
19         super().f()
20 
21 d = D()
22 d.f()
23 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

 1 class A:
 2     def f(self):
 3         print('in A')
 4 
 5 class B(A):
 6     pass
 7     # def f(self):
 8     #     print('in B')
 9 
10 class C(A):
11     pass
12     # def f(self):
13     #     print('in C')
14 
15 
16 class D(B,C):
17     pass
18     # def f(self):
19     #     print('in D')
20 
21 class E(C):
22     pass
23     # def f(self):
24     #     print('in B')
25 
26 class F(D,E):
27     pass
28     # def f(self):
29     #     print('in C')
30 
31 # d = D()
32 # d.f()
33 
34 print(F.mro())