面向对象之：类空间问题以及类之间的关系

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种:

1. 依赖关系
2. 关联关系
3. 组合关系
4. 聚合关系
5. 实现关系
6. 继承关系(类的三大特性之一：继承。)

但是在Python中,实际上只有3种:
1.依赖关系

2.组合关系

3.继承关系

转载于:https://www.cnblogs.com/zhangchaoyin/p/11378994.html

• 点赞
• 收藏
• 分享
• 文章举报