从空间角度研究类，类与类之间的关系

class A:
    address = '西安'
    def __init__(self,name):
        self.name = name

    def func(self):
        if self.name == 'dsb':
            self.skins = 'jlf'

    def func1(self):
        print(self.__dict__)
        A.aaa = 'ysh'


# obj = A('dsb')
# 类外面可以给对象封装属性
# respons = input('sbs')
# if respons == 's':
#     obj.wepon = 'AWM'
# print(obj.__dict__)
# 类的内部封装属性
# obj.func()
# print(obj.__dict__)
# A.teamp = '39.5'
# obj = A('dsb')
# print(A.__dict__)
# A.func1(111)
# A.func1(obj)
# print(A.__dict__)
class Person:

    mind ='ysx'
    language = 'hsyyy'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def work(self):
        print('gz')

# p1 =Person('dsb',21)
# print(p1.mind) #开辟一个新的类型空间
# p1.mind = 'wn'
# print(p1.mind)
# print(Person.mind)

# 对象如果查询一个属性：对象空间 -----> 类空间 ---->父类空间 ----->
# 类查询一个属性：类空间 ----> 父类空间---->
# 单向空间不可逆

# 对象与对象之间原则上相互独立。

-----------------------------------------------------------------------------------------------

class A:
    pass


class B:
    pass
'''
python 中类与类的关系
1、依赖关系 2、组合关系（关联组合聚合） 3、继承关系
'''

# 1、依赖关系 （主从）

# 大象进冰箱
class Elephant:
    def __init__(self,name):
        self.name = name

    def open(self,ref1,):
        # print(ref1)
        print(f'{self.name}大象默念三声：芝麻开门')
        ref1.open_door()

    def close(self,ref2,):
        print(f'{self.name}大象默念三声：芝麻关门')
        ref2.close_door()


class Refrigerator:

    def __init__(self,name):
        self.name =name

    def open_door(self):
        print(f'{self.name}冰箱门被打开了')

    def close_door(self):
        print(f'{self.name}冰箱门被关上了')

# ele = Elephant('七七')
# ele1 = Elephant('八八')
# ref = Refrigerator('美菱')
# ele1.open(ref)
# ele1.close(ref)

# 依赖关系：将一个类的类名或者对象传给另一个类的方法中

# 实现两个：
# 大象执行open方法：
# 显示：'哪个大象 大象。。。。'
# 显示：'哪个冰箱。。'

# 关门流程也完成

# 组合关系：（聚合，组合，关联）

class Boy:
    def __init__(self ,name,):
        self.name = name


    def meet(self,girl_friend=None):
        self.girl_friend = girl_friend


    def have_diner(self): #self = wu 这个对象空间
        if self.girl_friend:
            print(f'{self.name}请，年龄为：{self.girl_friend.age}，姓名为：{self.girl_friend.name}一起吃六块钱麻辣烫')
            self.girl_friend.shopping(self) #(self = wu 对象空间)
        else:
            print('单身狗吃什么吃')



class Girl:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def shopping(self,boy_friend):
        print(f'{boy_friend.name},{boy_friend.girl_friend.name}一起去购物！')


# wu = Boy('吴超')
# wu.have_diner(
# )# wu.meet('如花')
# flower = Girl('如花',48)
# 组合：将一个类的对象封装成另一个类的对象属性中
# wu.meet(flower)
# wu.have_diner()
# liu = Boy('刘华')
# wushang = Girl('无双',36)
# liu.meet(wushang)
# liu.have_diner()
'''
上面例题的难点：
一个类的方法只能由此类的对象去调用。
一个类的方法的第一个self只接受此类的对象。
'''
'''
模拟dota2写一个游戏人物的类（升级题）
要求：
1、创建一个Game_role的类
2、构造方法中给对象封装name，ad，hp。三个属性。
4、构建一个attack方法，此方法是实例化两个对象相互攻击的功能：
'''

class GameRole:
    def __init__(self,name,ad,hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p1):
        # print(self.name,p1.name)
        p1.hp = p1.hp - self.ad
        print(f'{self.name}平A{p1.name}，{p1.name}掉了{self.ad}血，还剩{p1.hp}血')


    def equit_weapon(self,wea):
        self.weapon = wea #组合：给fx这个对象封装类一个weapon属性值为，wea == jgb
        # print(self.name,wea.name)

    def use_jn(self,jnsh):
        self.jn = jnsh


class Weapon:

    def __init__(self,name,ad):
        self.name = name
        self.ad = ad

    def weapon_attack(self,p1,p2):
        p2.hp = p2.hp - (p1.ad + self.ad)
        print(f'{p1.name}装备{self.name}平A了{p2.name}，{p2.name}还剩{p2.hp}血')

class Jn:

    def __init__(self,name,ad):
        self.name = name
        self.ad =ad

    def jn_attack(self,p1,p2):
        p2.hp = p2.hp -  self.ad
        print(f'{p1.name}使用{self.name}对{p2.name}造成{self.ad}魔法伤害，{p2.name}还剩{p2.hp}血')



fx = GameRole('白丝风行',57,570)
js = GameRole('至宝剑圣',68,540)
# fx.attack(js)
# fx.attack(js)
# fx.attack(js)
# fx.attack(js)

# 利用武器攻击
jgb = Weapon('金箍棒',60)
fsf = Weapon('分身斧',40)
# jgb.weapon_attack(fx,js)
#上面需要解决的问题：发起武器攻击的发起者应该是角色，而不是武器
# 但是weapon_attack只能由Weapon类的对象去调用
fx.equit_weapon(jgb) #依赖关系
# print(fx.weapon)
# print(jgb)
# fx.weapon == jgb
# jgb.weapon_attack()
fx.weapon.weapon_attack(fx,js)
js.equit_weapon(fsf)
js.weapon.weapon_attack(js,fx)

qlj = Jn('强力击',150)
jsfb = Jn('剑圣风暴',350)
js.use_jn(jsfb)
js.jn.jn_attack(js,fx)

----------------------------------学习笔记，如有侵权，联系删除-----------------------------