类与类之间的关系
在我们的世界中事物和事物之间总会有一些联系.
在面向对象中,类和类之间也可以产生相关的关系
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
类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也 ⽤不到那么多. ⽤到了查就是了.