类与类之间的关系
类与类之间的关系
类与类中存在的关系：
1.依赖关系
2.关联关系
3.组合关系
4.聚合关系
5.继承关系
6.实现关系
python是一门弱类型编程语言，并且所有的对象之间其实都是多态关系，所有的东西都可以当做对象来使用。
一.依赖关系
依赖关系：我需要用你，但你不属于我，这种关系是最弱的。
例：把大象装进冰箱，创建大象、冰箱两个类
class Elephant:
def init(self,name):
self.name = name
def open(self,ref):
print('大象说：开门吧')
ref.open_door()
def close(self,ref):
print('大象说：关门吧')
ref.close_door()
def take(self):
print('大象走进冰箱')
class BingXiang:
def open_door(self):
print('冰箱:门开了')
def close_door(self):
print('冰箱:关好了')
r = BingXiang() # 造冰箱
el = Elephant('独立自主的大象') # 造大象
el.open(r) # 把冰箱当作参数传递进大象的类中，大象可以指定任何一个冰箱去进行操作
el.take()
el.close(r)
二.关联关系、组合关系、聚合关系
1.关联关系：两种事物必须是相互关联的，但是在某些特殊情况下是可以更改的和更换的。
2.聚合关系：属于关联关系中的一种特例，重点是xxx和xxx聚合城了xxx，各自有各自的声明周期，主体完蛋了，个体依然存在。
3.组合关系：属于关联关系中的一种特例，写法上差不多，组合关系比聚合关系还要紧密，主体完蛋了，个体跟着一起完蛋。
例:
男女朋友关系，可以是相互的也可以是单方面的
class Boy:
def init(self,name,girlFriend = None):
self.name = name
self.girlFriend = girlFriend
def yujian(self):
if self.girlFriend:
print('%s 和 %s 在一起吃饭' % (self.name,self.girlFriend.name))
else:
print('单身狗吃什么饭')
class Girl:
def __init__(self,name):
self.name = name
b = Boy('alex')
b.yujian()
g = Girl('王婆')
b.girlFriend = g # 有女朋友了
b.yujian() # 两个人一起吃饭
注:关联关系在逻辑上出现了，我需要你，你还要属于我，这种逻辑就是关联关系。
组合关系和聚合关系，代码上的差别不大，都是把另一类的对象作为这个类的属性来传递和保存，只是在含以上有不同。
三:继承关系
继承关系:子类在不影响父类的程序运行的基础上对父类进行扩充和扩展，我们可以父类成为超类或者基类，子类被称为派生类。
例：类名和对象默认是可以作为字典的key的
class Foo:
def __init__(self):
pass
def method(self):
pass
print(hash(Foo))
print(hash(Foo()))
# 既然可hash，那就说明字典的key可以是对象或者类
dic = {}
dic[Foo] = 123
dic[Foo()] = 456
print(dic) # {<class '__main__.Foo'>: 123, <__main__.Foo object at 0x00000000021D82E8>: 456}
四:self
接下来研究继承上的相关内容，主要研究self（不关方法之间如何进行调用，类与类之间是何关系，
默认的self都是访问这个方法的对象）
例1：
class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
class Foo(Base):
pass
obj = Foo(123)
obj.func1() # 123 运行的Base中的func1
例2:
class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
class Foo(Base):
def func1(self):
print("Foo. func1", self.num)
obj = Foo(123)
obj.func1() # Foo. func1 123 运⾏的是Foo中的func1
总结:self在访问方法的顺序：永远都是先找自己，自己找不到再到父类里找。
例3:
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 | 111 2 | 222 3
例4:
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.func1() # 1 111 1 | 2 111 2 | 3 222 3
总结:self就是你访问方法的那个对象，先找自己的，然后在找父类的。
五:类中的特殊成员
像__init__()这样，带上下划线的方法就属于特殊成员，在特殊的场景会被自动执行。
例:
- 类名() 会自动执行__init__()
- 对象() 会自动执行__call__()
- 对象[key] 会自动执行__getitem__()
- 对象[key] = value 会自动执行__setitem__()
- del 对象[key] 会自动执行 delitem()
- 对象+对象 会自动执行 add()
- with 对象 as 变量 会自动执行__enter__ 和__exit__
- 打印对象的 时候 会自动执行 str
- 干掉可哈希 hash == None 对象就不可哈希了.
创建对象的真正步骤：
首先, 在执行类名()的时候，系统会自动先执⾏__new__()来开辟内存，此时新开辟出来的内存区域是空的。
紧随其后系统⾃自动调用__init__()来完成对象的初始化操作，按照时间轴来算。
1.加载类
2.开辟内存(new)
3.初始化(init)
4.使用对象去执行什么