类的组合

类的组合,不同类的对象相互访问

class Gamerole:
    def __init__(self, nickname, ad, hp):
        self.nickname = nickname
        self.ad = ad
        self.hp = hp

    def attack(self, role):
        role.hp = role.hp - self.ad
        print('{0}攻击了{1}, {1}掉了{2}血,还剩{3}血'.format(self.nickname, role.nickname, self.ad, role.hp))

    def Transform(self, w, role2):  # 这个函数试着把两个类中的对象组合,执行时主语体现在第一个。效果和w1.fight(gailun, minjun)执行结果一样,
        self.w = w    # 所以只要把这个函数转换为以上函数就行了,首先把我w1和EquipentArms的对象联系起来
        return w.fight(self, role2)  # 然后返回该类中的一个fight方法
class EquipmentArms():  # 定义一个武器的类
    def __init__(self, name, ad):  # 每次都会执行此函数初识化对象
        self.name = name
        self.ad = ad

    def fight(self, role1, role2):
        role2.hp = role2.hp - role1.ad
        print('{}用{}攻击了{},{}掉了{}血,还剩{}血'.format(role1.nickname, self.name,\
                                                role2.nickname, role2.nickname, role1.ad,\
                                                role2.hp))


gailun = Gamerole('盖伦', 20, 200)
minjun = Gamerole('敏君', 10, 1000)
w1 = EquipmentArms('尚方宝剑', 30)
w2 = EquipmentArms('铁锤', 20)
gailun.Transform(w1, minjun)
# print(minjun.nickname)
# gailun.attack(minjun)
# w1.fight(gailun, minjun)  # 执行结果:盖伦用尚方宝剑攻击了敏君,敏君掉了200血,还剩960血
                          # 武器放在前面有点不合常理,应该把主语放在第一个,在语法看比较合适,

原理
两个类中的对象相互访问

三个类中的对象相互访问,类的组合 例:

class GameRole:  # 定义一个游戏角色的模板,框架
    def __init__(self, name, sex, age, ad, hp):  # 只要调用类,自动执行此方法,封装给角色属性。
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.hp = hp

    def action1(self, motor):   # 定义方法,涉及两个类,第一个是游戏角色对象本身,第二个要传摩托车类的一个对象 # 类的组合
        print('{}骑着{}开着{}的速度行驶在赛道上。'. \
              format(self.name, motor.name, \
                   motor.speed))   # 格式化输出,输出的内容自己定义,输出的格式是字符串,传给format函数参数。

    def action2(self, role):  # 一个类中两个对象对象的组合
        role.hp -= self.ad    # 为了程序的连贯性,要重新给被打的角色的血量这一属性重新赋值。
        print('{}赤手空拳打了{}{}滴血,{}还剩{}血'.format(self.name, role.name, self.ad, role.name, role.hp))

    def action3(self, role, weapon):  # 一般涉及几个类中的对象的组合,最好把主语放在第一位。比较符合逻辑,所以在主语的类中定义方法
        role.hp -= weapon.ad  # 计算被打对象剩余血量
        print('{}利用{}打了{}一{}, {}还剩{}血'.format(\
            self.name, weapon.name, role.name, weapon.name, role.name, role.hp ))

    def action4(self, role, motorcycle1, motorcycle2, weapon):  # 三个类中的角色相互访问
        role.hp -= weapon.ad
        print('{}骑着{}打了骑着{}的{}一{},{}哭了,还剩{}血'.format(self.name,\
                                                     motorcycle1.name, motorcycle2.name,\
                                                     role.name, weapon.name, role.name,\
                                                     role.hp))

class GameWeapon:  # 定义一个游戏武器的类
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

class GameMotorcycle:  # 定义摩托车总的类
    def __init__(self, name, speed):
        self.name = name
        self.speed = speed

role1 = GameRole('苍井井', 'female', 18, 20, 200)  # 调用了GameRole类模板,创建了role1具体的对象
role2 = GameRole('东尼木木', '男', 20, 30, 150)     # 实例化对象的过程,以及这个对象包含的属性
role3 = GameRole('波多多', '女', 19, 50, 80)

weapon1 = GameWeapon('平底锅', 20)  # 引用了武器的模板创建3个游戏武器
weapon2 = GameWeapon('斧子', 50)  # __init__ 有多少个形参就传多少个实参
weapon3 = GameWeapon('双节棍', 50)  # 对象没有方法,只有传进去的属性

motorcycle1 = GameMotorcycle('小踏板', 60)  # 实例化三个游戏摩托车
motorcycle2 = GameMotorcycle('雅马哈', 80)
motorcycle3 = GameMotorcycle('宝马', 120)

role1.action1(motorcycle1)  # 调用了两个类
role2.action1(motorcycle3)  # 调用了action1方法,开辟了临时命名空间
role3.action1(motorcycle2)

role1.action2(role3)  # 两个游戏角色的组合
role2.action2(role3)

role3.action3(role2, weapon2)

role1.action4(role2, motorcycle3, motorcycle1, weapon3)  # 三个类中的对象组合
role3.action4(role2, motorcycle1, motorcycle2, weapon2)

python内存运行机制
这里写图片描述

class Circle:  # 定义一个圆的类

    circumference_rate = 3.14159265   # 把圆周率定义为圆的一个属性

    def __init__(self, radius):  # 初始化一个圆的对象时传入半径
        self.radius = radius

    def circle_ference(self):   # 定义计算圆周长的方法
        print(round(2 * self.radius * self.circumference_rate, 2)) # 类中的属性调用方法,利用类指针去引用

    def circle_area(self):
        print(round((self.circumference_rate * self.radius) ** 2, 2))  # 定义计算圆面积的方法

circle1 = Circle(3)
circle1.circle_ference()
circle2 = Circle(5)  # 半径为5的实例化的一个对象
circle2.circle_area()  # 调用类的方法计算面积

class Ring:
    '''
    Define a Ring class
    '''
    circumference_rate = 3.14  # 定义圆周率属于圆环这个类的属性

    def __init__(self, radiuss, radiusb):  # 初识化对象时自动执行此方法,传入的是小圆和大圆的半径
        self.radiuss = radiuss
        self.radiusb = radiusb

    def ring_pirimeter(self,):  # 定义计算圆环周长的方法
        s = 2 * self.radiuss * self.circumference_rate  # 对象引用类里面的元素。
        b = 2 * self.radiusb * self.circumference_rate
        print(s + b)

    def ring_area(self):  # 定义类中圆环面积的方法
        sa = (self.radiuss * self.circumference_rate) ** 2  # 小圆的面积
        ba = (self.radiusb * self.circumference_rate) ** 2  # 大圆的面积
        print(ba - sa)

ring1 = Ring(4, 7)  # 实例化ring1
ring1.ring_pirimeter()  # 计算ring1的周长
ring2 = Ring(5, 9)   # 实例化ring2
ring2.ring_area()  # 计算ring2的面积
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值