第十七天-面向对象03-类与类的关系

# 依赖关系
# 在方法中给方法传递一个对象，把对象当成参数调用，此时类与类之间的关系是最弱的

# 大象装冰箱
class Elephant:
    def open(self,bx):  # 这里要放一个bx 依赖关系
        print("大象高高兴兴走到了冰箱面前")
        bx.kai()

    def zhuang(self):
        print("自己走进了冰箱")

    def close(self,bx): # 这里要放一个bx 依赖关系
        print("大象自己关闭了冰箱门")
        bx.guan()

class Ice:
    def kai(self):
        print("我是冰箱，我开门了")
    def guan(self):
        print("我是冰箱，我关门了")

bx1 = Ice()
dx = Elephant()
dx.open(bx1) # 这里把bx1作为一个参数传递进去了 也就是 大象可指定任何一冰箱
dx.zhuang()
dx.close(bx1)

# 植物大战僵尸

class Jiangs:
    @classmethod
    def zd(cls):
        print("战斗开始！")

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

    def chi(self,zw): # 把zw对象作为一个参数给chi调用
        zw.hp -= self.power
        print("%s对%s造成了%s伤害"%(self.name,zw.name,self.power))
        print("%s还有%s血"%(zw.name,zw.hp))

class Zhiw:
    def __init__(self,name,power,hp):
        self.name = name
        self.power = power
        self.hp = hp

    def da(self,js): # 把js对象作为一个参数给da调用
        js.hp -= self.power
        print("%s对%s造成了%s伤害" % (self.name, js.name, self.power))
        print("%s还有%s血" % (js.name,js.hp))


zw1 = Zhiw("豌豆战士",50,300)
js1 = Jiangs("看报僵尸",1000,30)

# Jiangs.zd()
# js1.chi(zw1)
# zw1.da(js1)
# js1.chi(zw1)
# zw1.da(js1)
# js1.chi(zw1)
# zw1.da(js1)

# 关联关系
# 两种事物必须是相互关联的，但在某些情况是可以更改的

# 男女朋友
class Boy:
    def __init__(self,name,girlfriend = None):
        self.name = name
        self.girlfriend = girlfriend

    def play(self):
        if self.girlfriend:
            self.girlfriend.happy() # 调用g的方法happy
            print("%s和%s在玩游戏"% (self.name,self.girlfriend.name))
        else:
            print("没女朋友玩什么玩")

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

    def happy(self):
        print("有好玩的好开心")

g = Girl("尼美")
b = Boy("尼玛",g) # g赋值给b对象的girlfriend属性

# b.play()
# b.girlfriend = None # 突然有天闹掰了
# b.play()

# 老师和学生的关系，一对多，反过来一对一多对一

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): # 输出学生 s
        for s in self.lst:
            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(s3)
# t.tianjia(s4)
#
# t.display()

# 聚合关系 代码上写法与关联一样
# 属于关联关系中的一种特例.不过侧重点是xxx和xxx聚合成xxx.各自有各自的声明
# 周期.如电脑.电脑里有CPU,硬盘,内存等等.电脑挂了.CPU还是好的.还是完整的个体
# 如下：

# 各个类组合成电脑类，但分开又能是单独的个体

class Computer:

    def __init__(self, cpu, memory, yingpan, zhuban, xianshiqi):
        pass

class Cpu:
    pass

class Memory:
    pass

# 组合关系 代码上写法与关联一样
# 属于关联关系中的一种特例,写法上差不多.组合关系比聚合还紧密.如⼈,
# 人的大脑,心脏,各个器官.这些器官组合成一个⼈.这时.⼈如果挂了.其他的东西也跟着挂了.

# 关联关系 一对多，反过来一对一多对一  在如：商城购物、通讯软件等广泛使用

# 练习 帖子和评论

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)  # 打印 pl.content 评论内容

# 继承关系之self
'''
在面向对象的世界中存在着继承关系.现实中也存在着这样的关系.我们说过.x是一种y,那x就可以继承y.这时理解层面上的.如果
上升到代码层面.我们可认为.子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展.这里.我们可把父类称为超类或者基类.子类被称为派生类. 
'''

# 类名和对象默认是可以作为字典的key的
class Foo:
    def __init__(self):
        pass

    def method(self):
        pass

    # __hash__ = None  # 该类的对象就不可哈希了

print(hash(Foo))  # 类 可hash(不可改变)的
print(hash(Foo())) # 对象 可hash的
# 可哈希 所以字典的key可以是对象或者类
dic = {}
dic[Foo] = 123
dic[Foo()] = 456
# print(dic)  # 打印如下 是可用的
# {<class '__main__.Foo'>: 123, <__main__.Foo object at 0x000002BC7568EBE0>: 456}

# dic = {Foo:Foo(),Foo():"疙瘩汤"} # 可用

# 不可哈希
# list   # unhashable type: 'list'  __hash__ = None
s = []
# print(hash(s))  # list不可哈希

# 所以想要谁不可哈希 可添加 __hash__ = None
# 如上面类中添加 __hash__ = None 该类的对象就不可哈希了

# self 谁调用就是谁的

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()   # 111,1  222,2  222,3

# self在访问方法的顺序: 永远先找自己的.自己的找不到再找父类的.

# 类名是变量(类似函数名)

class Car:
    def run(self):
        print("我的车会跑")

CarCarCar = Car # 类名是变量
c = CarCarCar()
# c.run()

# 函数名是变量
def func():
    print("我是函数")

# func()
#
# fn = func
# fn()

# 特殊成员
#  __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  对象就不可哈希了.
10.__repr__()  def __repr__(self):  一个对象的官方字符串表示形式
11.__iter__()  可迭代的
12.__next__()  获取元素
13.__new__() 真正的构造方法. 用来创建对象的. 开辟内存
14.__len__() 返回序列元素个数
15. < 时自动执行  __lt__()   > 时 自动执行  __gt__()
16. <=  自动执行  __le__()   >=  自动执行  __ge__()     == 时 执行  __eq__()
17.  __dir__   dir()
18. __getslice__   对象[::]
19. __dict__ 查看当前想的属性
20. __class__  指一个对象的类型
'''