python-day17 类与类之间的关系

一. 类与类之间的依赖关系

　　依赖关系就相当于兼职工,公司需要你就来,不需要也可以换其他人     依赖关系: 我用你但你不属于我

#依赖关系
# class Daxiang:
#     def open(self,bx):
#         print('大象高高兴兴走到了冰箱的面前')
#         bx.kai()
#         print('大象打开了冰箱门')
#     def zhuang(self):
#         print('大象走进了冰箱')
#     def close(self,bx):
#         print('大象要关冰箱门了')
#         bx.guan()
# class BinXiang:
#     def kai(self):
#         print('我是冰箱,我会开门')
#     def guan(self):
#         print('我是冰箱,我会关门')
#
# ret = Daxiang()
# bx = BinXiang()

# ret.open(bx)
# ret.zhuang()
# ret.close(bx)

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

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

　　　　　　  我需要你,你也属于我,这就是关联关系

　　聚合关系  属于关联关系的一种特例===>各有各自的声明周期, 比如电脑,电脑里有CPU,硬盘,内存等等,

　　　　　　  电脑死机了,CPU还是好的,还是个完整的个体

　　组合关系  属于关联关系的一种特例===> 组合关系比聚合关系更加紧密,比如大脑,心脏等重要器官组成一个人,

　　　　　　  如果人死了,这些器官也跟着死了

# 关联关系
# class Boy:
#     def __init__(self,name,girlFriend = None):
#         self.name = name
#         self.girlFriend = girlFriend #关联关系
#     def chi(self):
#         if self.girlFriend:
#             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('桐木')
# a = Girl('爱丽丝')
# b.chi()

# b对象的girlFriend赋值  g
# b.girlFriend = a   #突然天降女朋友
# b.chi()
# b.girlFriend = None
# b.chi()

三. 继承关系

　　类名和对象默认是可以作为字典的key键的

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

　　self就是你访问方法的那个对象, 先找自己,然后再找父类的

四. 类的的特殊成员

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 对象就不可哈希了了.

# 特殊成员
# class Car:
#     def __init__(self,color,pai): # 类名() 自动执行__init__()
#         self.color = color
#         self.pai = pai
#     def __call__(self, *args, **kwargs): #对象() 自动执行__call__()
#         print('证明来过')
#     def __getitem__(self, item): #对象[key] 自动执行__getitem__()
#         print('这是getitem,item = ',item)
#     def __setitem__(self, key, value):
#         print(key,value)
#     def __delitem__(self, key):
#         print(key)
#     def __add__(self, other): #对象+对象会自动执行
#         print("证明我来过")
#     def __enter__(self):
#         print('进来的时候')
#     def __exit__(self, exc_type, exc_val, exc_tb):
#         print('出去的时候')
#     def __str__(self):## 当前对象的字符串表示形式
#         return '111'
#     def __repr__(self):#  一个对象的官方字符串表示形式
#         return '我的车很厉害'
#     def __iter__(self):
#         return (i for i in range(10))
#     def __hash__(self):
#         __hash__ = None #干掉可哈希  __hash__ == None  对象就不可哈希了了.
        # pass

# ret = Car('red','6666') #执行__init__
# ret() #执行__call__()
# ret['key']#执行__getitem__()
# ret['abc'] = '123' #执⾏__setitem__()
# del ret['abc']#执行 __delitem__()
# b = Car('a','1')
# a = b+ret    #执行__add__()
# with ret as m:   #执行__enter__ 和__exit__
#     print('哈哈哈')
# print(ret)#执行 __str__
# print(repr(ret))#执行__repr__()
# for i in ret: # 执行__iter__
#     print(i)
# print(hash(ret)) #执行 __hash__()

class Car:
    def __init__(self, color, pai): # 初始化方法
        print("哪有地呀")
        self.color = color
        self.pai = pai

    # 这里才是真正的构造方法
    def __new__(cls, *args, **kwargs):
        print("我的天哪")
        # 固定的返回值
        return object.__new__(cls)

c = Car("红色", "京A66666") # 先执行__new__ 返回object.__new__(cls).把返回的空对象传递给 __init__()

print(c.color)