面向对象之:类空间问题以及类之间的关系
1.从空间角度研究类
1.何处添加对象属性
class A:
def __init__(self,name):
self.name = name
def func(self,sex):
self.sex = sex
# 类外面可以:
obj = A('barry')
obj.age = 18
print(obj.__dict__) # {'name': 'barry', 'age': 18}
# 类内部也可以:
obj = A('barry') # __init__方法可以。
obj.func('男') # func 方法也可以。
2.何处添加类的属性
class A:
def __init__(self,name):
self.name = name
def func(self,sex):
self.sex = sex
def func1(self):
A.bbb = 'ccc'
# 类的外部可以添加
A.aaa = 'taibai'
print(A.__dict__)
# 类的内部也可以添加。
A.func1(111)
print(A.__dict__)
总结:类的属性不仅可以在类内部添加,还可以在类的外部添加。
3.对象如何找到类的属性
对象查找属性的顺序:先从对象空间找 ------> 类空间找 ------> 父类空间找 ------->.....
类名查找属性的顺序:先从本类空间找 -------> 父类空间找--------> ........
上面的顺序都是单向不可逆,类名不可能找到对象的属性。
2.类与类之间的关系
1.对象空间与类空间的关系
对象空间与类空间有相同的名字, 对象. 肯定先从对象空间查找.
查询顺序:
对象.名字: 对象空间 类对象指针 --> 类空间 ---> 父类空间
类名.名字: 类空间 -----> 父类空间
1.类与类之间的关系
1.依赖关系
将一个类的类名或者对象传入到另一个类的方法中.
#1. 依赖关系: 主从之分.
class Elephant:
def __init__(self,name):
self.name = name
def open(self,obj):
print(f'{self.name} 默念三声: 3,2,1 开门')
obj.be_open()
def close(self):
print(f'{self.name} 默念三声: 3,2,1 关门')
class Refrigerator:
def __init__(self, name):
self.name = name
def be_open(self):
print(f'{self.name}冰箱 被打开了')
def be_close(self):
print(f'{self.name}冰箱 被关闭了')
# 依赖关系: 将一个类的类名或者对象传入另一个类的方法中.
qiqi = Elephant('奇奇')
haier = Refrigerator('海尔')
qiqi.open(haier)
2.组合关系
给一个类的对象封装一个属性,此属性为另一个类的对象
# 2. 组合关系
# class Boy:
#
# def __init__(self, name, girlfriend=None):
# self.name = name
# self.girlfriend = girlfriend
#
# def have_a_diner(self):
# if self.girlfriend:
# print(f'{self.name}请他的女朋友{self.girlfriend}一起烛光晚餐')
# else:
# print('单身狗,吃什么吃')
# liye = Boy('李业')
# liye.have_a_diner()
# liye = Boy('李业')
# # 只是给李业封装了一个属性:girlfriend 为一个字符串的数据
# liye.girlfriend = '乔碧萝'
# liye.have_a_diner()
# class Boy:
#
# def __init__(self, name, girlfriend=None):
# self.name = name
# self.girlfriend = girlfriend
#
# def have_a_diner(self):
# if self.girlfriend:
# print(f'{self.name}请他的{self.girlfriend.age}岁的,{self.girlfriend.body}的女朋友{self.girlfriend.name}一起烛光晚餐')
# else:
# print('单身狗,吃什么吃')
#
# def girl_skill(self):
# print(f'{self.name}的女朋友的技能:')
# self.girlfriend.skill()
#
# class Girl:
#
# def __init__(self,name,age,body):
# self.name = name
# self.age = age
# self.body=body
#
# def skill(self):
# print(f'{self.name} 会用萝莉音直播')
#
#
# liye = Boy('李业')
# qiao = Girl('乔碧萝', 58, '小钢炮')
# liye.girlfriend = qiao
# # liye.have_a_diner()
# liye.girl_skill()
# class GameRole:
#
# def __init__(self, name, ad, hp):
# self.name = name
# self.ad = ad
# self.hp = hp
#
# def attack(self, p1):
# p1.hp = p1.hp - self.ad
# print(f"{self.name}攻击{p1.name},谁掉了{self.ad}血, 还剩{p1.hp}血")
# print(f'{p1.name}的血量{p1.hp}')
#
# class Weapon:
#
# def __init__(self,name,ad):
# self.name = name
# self.ad = ad
#
# def weapon_attack(self, p1, p2): # 依赖关系
#
# p2.hp = p2.hp - self.ad
# print(f'{p1.name}利用{self.name}给了{p2.name}一下子,{p2.name}掉了{self.ad}血,还剩{p2.hp}血')
#
#
#
# gailun = GameRole('盖伦', 10, 100)
# xin = GameRole('菊花信', 20, 80)
# Sword = Weapon('大宝剑',15)
# Musket = Weapon('长缨枪',30)
# 盖伦利用大宝剑给赵信一下子
# Sword.weapon_attack(gailun, xin)
# 1. 功能虽然实现了,但是逻辑上不合理,应该是人物对象调用方法.主体.
# 2. 游戏人物本身就应该绑定武器属性.
class GameRole:
def __init__(self, name, ad, hp):
self.name = name
self.ad = ad
self.hp = hp
def attack(self, p1):
p1.hp = p1.hp - self.ad
print(f"{self.name}攻击{p1.name},谁掉了{self.ad}血, 还剩{p1.hp}血")
print(f'{p1.name}的血量{p1.hp}')
def equipment_wea(self, wea):
self.weapon = wea # 组合关系
class Weapon:
def __init__(self,name,ad):
self.name = name
self.ad = ad
def weapon_attack(self, p1, p2): # 依赖关系
print(f'self---->: {self}') # self 永远默认接受本类实例化对象
p2.hp = p2.hp - self.ad
print(f'{p1.name}利用{self.name}给了{p2.name}一下子,{p2.name}掉了{self.ad}血,还剩{p2.hp}血')
gailun = GameRole('盖伦', 10, 100)
xin = GameRole('菊花信', 20, 80)
Sword = Weapon('大宝剑',15)
Musket = Weapon('长缨枪',30)
# 给游戏人物封装武器属性
gailun.equipment_wea(Sword)
# print(gailun.__dict__)
# gailun.weapon.weapon_attack()
# print(f'gailun: ---> {gailun}')
# print(f'Sord: ---> {Sword}')
gailun.weapon.weapon_attack(gailun,xin)
依赖(dependency)关系也是表示类与类之间的连接,表示一个类依赖于另外一个类的定义,依赖关系时是单向的。简单理解就是类A使用到了类B,这种依赖具有偶然性、临时性,是非常弱的关系。但是类B的变化会影响到类A。举个例子,如某人要过河,则人与船的关系就是依赖,人过河之后,与船的关系就解除了,因此是一种弱的连接。在代码层面,为类B作为参数被类A在某个方法中使用。
组合(compostion)也是关联关系的一种特例,体现的是一种contain-a关系,比聚合更强,是一种强聚合关系。它同样体现整体与部分的关系,但此时整体与部分是不可分的,整体生命周期的结束也意味着部分生命周期的结束,反之亦然。如大脑和人类。
原本在UML中类与类的关系有6种:
- 依赖关系
- 关联关系
- 组合关系
- 聚合关系
- 实现关系
- 继承关系(类的三大特性之一:继承。)
但是在Python中,实际上只有3种:
1.依赖关系
2.组合关系
3.继承关系