day 18 类与类之间的关系

类与类之间的关系

    在我们的世界中事物和事物之间总会有一些联系.

   在面向对象中,类和类之间也可以产生相关的关系

1.依赖关系

    执行某个动作的时候. 需要xxx来帮助你完成这个操作, 此时的关系是最轻的.

    随时可以更改换另一个东西来完成此操作

class Person:

    def play(self, tools): # 通过参数的传递把另外一个类的对象传递进来

        tools.run()

        print("很开心, 我能玩儿游戏了")

 

 

class Computer:

    def run(self):

        print("电脑开机. 可以运行")

 

class Phone:

    def run(self):

        print("手机开机, 可以运行")

 

c = Computer()

phone = Phone()

p = Person()

p.play(phone)

##植物大战僵尸

写一个植物大战僵尸

# 1. 植物

#       打僵尸. 僵尸掉血

# 2. 僵尸

#       吃植物. 植物掉血

 

class Plant:

    def __init__(self, name, hp, ad): # 200

        self.name = name

        self.hp = hp

        self.ad = ad

 

    def attack(self, js):

        print("植物攻击僵尸")

        js.hp -= self.ad

        print(f"僵尸掉血{self.ad}, 还剩下{js.hp}")

 

class JiangShi:

    def __init__(self, name, hp, ad): # 1000  800

        self.name = name

        self.hp = hp

        self.ad = ad

 

    def attack(self, zw):

        print("僵尸咬植物")

        zw.hp -= self.ad

        print(f"植物掉血{self.ad}, 还剩{zw.hp}")

 

 

# 植物

wd = Plant("歪脖子豌豆", 10, 20)

# 僵尸

js = JiangShi("铁桶僵尸", 200, 1)

wd.attack(js)

wd.attack(js)

wd.attack(js)

wd.attack(js)

wd.attack(js)

 

js.attack(wd)

js.attack(wd)

js.attack(wd)

js.attack(wd)

关联关系

  在对象里面埋对象

    1.一对一的关系

class Boy:

 

    def __init__(self, name,  girlFriend=None):

        # 在初始化的时候可以给一个对象的属性设置成另一个类的对象

        self.girlFriend = girlFriend  # 一个男孩有一个女朋友

 

    def chi(self):

        if self.girlFriend:

            print(f"带着他的女朋友{self.girlFriend.name}去吃饭")

        else:

            print("单身狗, 吃什么吃? 滚去学习.")

 

    def movie(self):

        if self.girlFriend:

            print(f"带着他的女朋友{self.girlFriend.name}去看电影")

        else:

            print("单身狗, 看什么看? 滚去学习.")

 

 

class Girl:

    def __init__(self, name):

        self.name = name

 

b = Boy("宝浪")

g = Girl("孙艺珍")

b.chi()

 

# alex给包浪介绍了一个女朋. 孙艺珍

b.girlFriend = g

b.chi()

 

g2 = Girl("梁咏琪")

b.girlFriend = g2 # 换了个女朋友

b.chi()

      2.一对多关系

##一个学校.一堆老师

class School:

    def __init__(self, name):

        self.teach_list = []

        self.name = name

 

    def zhaopin(self, teach):

        self.teach_list.append(teach)

 

    def shangke(self):

        for t in self.teach_list:

            t.work()

 

 

class Teacher:

    def __init__(self, name):

        self.name = name

 

    def work(self):

        print(f'{self.name}在上课')

 

lnh = School('蓝翔')

t1 = Teacher("武sir")

t2 = Teacher("太白")

t3 = Teacher("哪吒")

t4 = Teacher("女神")

t5 = Teacher("日天")

t6 = Teacher("宝浪")

 

lnh.zhaopin(t1)

lnh.zhaopin(t2)

lnh.zhaopin(t3)

lnh.zhaopin(t4)

lnh.zhaopin(t5)

lnh.zhaopin(t6)

 

lnh.shangke()

类中的关系:   依赖关系式最轻的.  最重的是继承关系.关联关系是比较微妙的

     3.在继承关系中注意的:   self到底是谁?

self: 谁调用的就是谁,  类型是根据调用方的对象来进行变换的

super: 表示的是父类

特殊成员:

__init__()  #创建对象的时候初始化操作，构造器

    __del__()  # 析构器，当一个实例被销毁的时候调用的方法

    __call__()  # 对象（）

    __getitem__() # 对象[key]

    __setitem__()  # 对象[key] = value

    __new__()   # 创建对象的时候，开辟内存

    __enter__()  # with对象 as 变量

    __exit__()  # 结束with的时候

    __hash__() # 可哈希 hash()  __hash__ = None 干掉可哈希

    __str__ 打印对象的时候会自动执行

    __delitem__() del对象[key]时执行

    __add__() 对象+对象

    __doc__ 查看类的描述信息

    __module__ 表示当前操作的对象所在模块

    __class__ 当前操作对象所处的类

    __iter__() 定义迭代器

    __contains__(self,item)  定义当使用成员测试运算符（in 活 not in）时的行为

创建对象的真正步骤: 

⾸先, 在执⾏类名()的时候. 系统会⾃动先执⾏__new__()来开辟内存. 此时新开辟出来的内 存区域是空的. 紧随其后, 系统⾃动调⽤__init__()来完成对象的初始化⼯作. 按照时间轴来算.

 1. 加载类 

2. 开辟内存(__new__) 

3. 初始化(__init__) 

4. 使⽤对象⼲xxxxxxxxx 

类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也 ⽤不到那么多. ⽤到了查就是了.