类与类之间的关系(依赖关系,大象与冰箱是依赖关系)

class DaXiang:

def open(self, bx): # 这里是依赖关系. 想执行这个动作. 必须传递一个bx

print("大象高高兴兴走到了冰箱的面向前")

bx.kai() # 传递来的对象执行kai()动作

print("大象成功的打开了冰箱门")

def zhuang(self):

print("自己走进了冰箱")

def close(self, bx):

print("大象要关冰箱门了")

bx.guan()

class BingXiang:

def kai(self):

print("我是冰箱. 我会开门 ")

def guan(self):

print("我是冰箱. 我会关门 ")

bx1 = BingXiang()

bx2 = BingXiang()

dx = DaXiang()

dx.open(dfg)

dx.zhuang()

dx.close(dfg)

例二 植物大战僵尸

# 植物大战僵尸. 创建一个植物. 创建一个僵尸

# 植物: 名字, 攻击力

# 僵尸: 名字, 血量

# 植物可以打僵尸. 僵尸掉血

# 显示出僵尸挨揍之后的血量

class ZhiWu:

def __init__(self, name, attack, hp):

self.name = name

self.attack = attack

self.hp = hp

def fight(self, js):

js.hp -= self.attack

class JiangShi:

def __init__(self, name, hp, attack):

self.name = name

self.hp = hp

self.attack = attack

def chi(self, zhiwu):

zhiwu.hp -= self.attack

lvluo = ZhiWu("绿萝", 20, 10)

js1 = JiangShi("僵尸一号", 100, 5)

lvluo.fight(js1)

lvluo.fight(js1)

lvluo.fight(js1)

js1.chi(lvluo)

js1.chi(lvluo)

js1.chi(lvluo)

print(lvluo.hp)

print(js1.hp)

?. 关联关系.组合关系, 聚合关系

其实这三个在代码上写法是?样的. 但是, 从含义上是不?样的.

1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.

2. 聚合关系. 属于关联关系中的?种特例. 侧重点是xxx和xxx聚合成xxx. 各?有各?的

声明周期. 比如电脑. 电脑?有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是

完整的个体

3. 组合关系. 属于关联关系中的?种特例. 写法上差不多. 组合关系比聚合还要紧密. 比

如?的?脑, ?脏, 各个器官. 这些器官组合成?个?. 这时. ?如果挂了. 其他的东?

也跟着挂了

关联关系

简单来说就是一对一的关系

例子一

class Boy:

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

self.name = name

self.girlFriend = girlFriend # 关联关系

def chi(self): # b

if self.girlFriend:

self.girlFriend.happy()

print("%s和%s在吃饭" % (self.name, self.girlFriend.name))

else:

print("没女朋友吃什么吃")

class Girl:

def __init__(self, name):

self.name = name

def happy(self):

print("有好吃的就开心")

b = Boy("王明")

g = Girl("肉丝")

# b对象的girlFriend赋值 g

b.girlFriend = g # 突然天降女朋友

b.chi()

b.girlFriend = None

b.chi()例

例二老师和学生的关系. 一对多的关系 反过来就是一对一

class Teacher:

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

self.name = name

if lst == None: # 判断传递过来的参数是否是空

self.lst = []

else: # 传递过来的是一个列表

self.lst = lst

# 添加学生

def tianjia(self, student):

self.lst.append(student)

def display(self):

for s in self.lst: # s 是老师的学生

print(s.name)

class Student:

def __init__(self, num, name, teacher=None):

self.name = name

self.num = num

self.teacher = teacher

t = Teacher("大张伟")

s1 = Student(1, "郭德纲")

s2 = Student(2, "岳云鹏")

s3 = Student(3, "张鹤伦")

s4 = Student(4, "朱云峰")

t.tianjia(s1) # 把学生添加给老师

t.tianjia(s2)

t.tianjia(s4)

# 帖子和评论

class Tie:

def __init__(self, title, content, author, time, pinglun_lst = None):

self.title = title

self.content = content

self.author = author

self.time = time

if pinglun_lst == None:

self.pinglun_lst = []

else:

self.pinglun_lst = pinglun_lst

class Pinglun:

def __init__(self, name, time, content, fav):

self.name = name

self.time = time

self.content = content

self.fav = fav

pl1 = Pinglun("UZI", "昨天1", "UZI发出祝福",1888888)

pl2 = Pinglun("xiaohu", "昨天2", "UZI发出祝福",1888888)

pl3 = Pinglun("若风", "昨天3", "UZI发出祝福",1888888)

pl4 = Pinglun("let me", "昨天3", "UZI发出祝福",1888888)

pl5 = Pinglun("长长", "昨天4", "UZI发出祝福",1888888)

pl6 = Pinglun("jackylove", "昨天5", "UZI发出祝福",1888888)

pl7 = Pinglun("mlxg", "昨天6", "UZI发出祝福",1888888)

pl8 = Pinglun("miss", "昨天7", "UZI发出祝福",1888888)

lst = []

lst.append(pl1)

lst.append(pl2)

lst.append(pl3)

lst.append(pl4)

lst.append(pl5)

lst.append(pl6)

lst.append(pl7)

lst.append(pl8)

# 显示帖子的内容. 评论的内容

tie = Tie("S8_IG夺冠. 王思聪怒吃热狗. ", "IG的上单The Shy疯了一样. 一个打5个. 自己人都不放过", "王明","某年某月某一天",lst )

print(tie.content)

# 评论

# print(tie.pinglun_lst)

for pl in tie.pinglun_lst:

print(pl.content)

继承关系,指的是子类继承父类除私有属性外所有的属性.

class Base:

def __init__(self, num):

self.num = num

def func1(self):

print(self.num)

self.func2()

def func2(self):

print(111, self.num)

class Foo(Base):

def func2(self):

print(222, self.num)

lst = [Base(1), Base(2), Foo(3)]

for obj in lst:

obj.func2()

四. 类中的特殊成员

什么是特殊成员呢? __init_()就是?个特殊的成员. 说?了. 带双下划线的那?坨. 这些?

法在特殊的场景的时候会被?动的执?. 比如,

1. 类名() 会?动执?__init__()

2. 对象() 会?动执?__call__()

3. 对象[key] 会?动执?__getitem__()

4. 对象[key] = value 会?动执?__setitem__()

5. del 对象[key] 会?动执? __delitem__()

6. 对象+对象 会?动执? __add__()

7. with 对象 as 变量 会?动执?__enter__ 和__exit__

8. 打印对象的时候 会?动执? __str__

9. ?掉可哈希 __hash__ == None 对象就不可哈希了.

创建对象的真正步骤:

?先, 在执?类名()的时候. 系统会?动先执?__new__()来开辟内存. 此时新开辟出来的内

存区域是空的. 紧随其后, 系统?动调?__init__()来完成对象的初始化?作. 按照时间轴来算.

1. 加载类

2. 开辟内存(__new__)

3. 初始化(__init__)

4. 使?对象?xxxxxxxxx

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

?不到那么多. ?到了查就是了.