4-12日 面向对象的组合和继承

1，面向对象的组合

组合就是一种什么有什么的关系。

一个类的对象可以作为另一个类的属性。

为什么会用组合，独立的对象，不能发挥它的作用，必须依赖一个对象。

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好.

人狗大战的升级版本

class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        print('%s攻击了%s,%s掉了%s滴血'%(self.name,dog.name,dog.name,self.ad))
        dog.hp -= self.ad
    def pay(self):
        money = int(input('请输入您充值的金额:'))
        self.money += money
        print('您的余额是:%s'%self.money)
    def wear(self,weapon):
        if self.money >= weapon.price:
            self.weapon = weapon
            self.money -= weapon.price
            print('您已购买成功，您已经顺利装备了%s'%weapon.name)
        else:
            print('余额不足，请充值。')
    def attack_with_weapon(self):
        if 'weapon'in alex.__dict__:
            alex.weapon.skill(teddy)
        else:
            print('请先装备武器')
class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬了%s一口,%s掉了%s滴血'%(self.name,person.name,person.name,self.ad))
        person.hp -= self.ad
class Weapon:
    def __init__(self,name,price,ad,level):
        self.name = name
        self.price = price
        self.level = level
        self.ad = ad *self.level
    def skill(self,dog):
        dog.hp -= self.ad
        print('%s受到了%s的伤害,%s掉了%s滴血'%(dog.name,self.name,dog.name,self.ad))

alex = Person('a_sb','male',45,40)
boss_jin = Person('太把','male',60,50)
teddy = Dog('小虎','teddy',300,60)
fotou = Weapon('斧头',1000,100,1)

lis = ['攻击','充值','装备武器','使用武器攻击']
while True:
    for index,value in enumerate(lis,1):
        print(index,value)
    num = int(input('请选择操作序号<<<'))
    if num == 1:
        alex.attack(teddy)
    elif num == 2:
        alex.pay()
    elif num == 3:
        print('装备前余额%s'%alex.money)
        alex.wear(fotou)
        print('装备后余额%s'%alex.money)
    elif num == 4:
        alex.attack_with_weapon()
    else:
        print('无效的序号')

计算圆环面积和周长（用类的组合）

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 pi *self.r *2
class Ring:
    def __init__(self,out_r,in_r):
        self.out_circle = Circle(out_r)
        self.in_circle = Circle(in_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()

ring1 = Ring(20,12)
print(ring1.area())
print(ring1.perimeter())

班级和老师之间的组合方法

class Clas:
    def __init__(self,name,num,course,type):
        self.name = name
        self.num = num
        self.course = course
        self.type = type
class Teacher:
    def __init__(self,name,sex,age,py11):
        self.name = name
        self.sex = sex
        self.age = age
        self.cls = py11

py11 = Clas('无敌11期',96,'python','脱产全栈')
print(py11.course)

boss_jin = Teacher('太白','male',33,py11)

print(py11.course)
print(boss_jin.cls.num)
print(boss_jin.cls.name)
print(boss_jin.cls.course)

2，继承

继承:类和类之间的关系，是什么是什么的关系。

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

class Parent:pass
class Son(Parent):pass
print(Son.__bases__)

Son就继承了Parent,可以用  __bases__ 查看。

在python 3中所用的类都会默认继承object类，继承了object类的所有类都是新式类，如果一个类没有继承任何父类，那么__bases__的属性就会显示< class  object>

继承有单继承和多继承、

class Parent1:pass
class Parent2:pass
class Son(Parent1):pass
class Son(Parent1,Parent2):pass
print(Son.__bases__)

父类又称基类，超类，子类又称派生类。

class Animal:
    role = 'Animal'
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s吃药回血了'%self.name)
class Person(Animal):
    r = 'Person'
    def attack(self,dog):
        print('%s攻击了%s'%(self.name,dog.name))
    def eat2(self):
        print('执行了Person类的eat方法')
        self.money = 100
        self.money -= 10
        self.hp += 10
class Dog(Animal):
    def bite(self,person):
        print('%s咬了%s'%(self.name,person.name))

alex = Person('alex',10,5)
print(Person.__dict__)
print(Person.role)
print(alex.__dict__)
dog =Dog('teddy',100,20)
print(dog)
print(dog.__dict__ )

对象使用名字的顺序，先找对象自己的内存空间中的，再找对象对象自己类中的，再找父类中的。

继承父类的方法，自己没有同名的方法就继承父类的，有就用自己的。和使用名字的顺序一样。

先抽象再继承。即抽取类似或者说比较像的部分。