02面向对象之:类空间问题及类之间的关系

一.类的空间问题

1.何处可以添加对象属性

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def func(self,sex):
        self.sex = sex
# 类的外面可以
obj =A('alex',12)
obj.heght=122
print(obj.__dict__)
{'name': 'alex', 'age': 12, 'heght': 122}

# 内部也可以
obj.func('nv')
print(obj.__dict__)
{'name': 'alex', 'age': 12, 'heght': 122, 'sex': 'nv'}

总结：对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加。

 

1.2何处可以添加类的静态属性

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def func(self,sex):
        self.sex = sex
        print(666)
    def func1(self):
        A.country='zhonguo'


# 类的外部可以添加
A.aaa = 666
print(A.__dict__)

# 类的内部也可以添加
A.func1(12321)
print(A.__dict__)

总结:类的属性不仅可以在类内部添加,还可以在类的外部添加

 

1.3 对象如何找到类的属性

之前咱们都学习过，实例化一个对象，可以通过点的方式找到类中的属性，那么他为什么可以找到类中的属性呢？

通过图解说明：

对象查找属性的顺序：先从对象空间找  ------> 类空间找 ------> 父类空间找 ------->.....

类名查找属性的顺序：先从本类空间找 -------> 父类空间找--------> ........

上面的顺序都是单向不可逆，类名不可能找到对象的属性。

 

 二.类与类之间的关系

 

大千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进⾏归类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类中存在以下关系:

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

 

2.1 依赖关系

 

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

    def open(self,obj1):
        '''
        开⻔

        '''
        print('大象要开门了，默念三声，开')
        obj1.open_door()

    def close(self):
        '''
        关⻔
        '''
        print('大象要关门了，默念三声，关')


class Refrigerator:

    def open_door(self):
        print("冰箱⻔被打开了")

    def close_door(self):
        print("冰箱⻔被关上了")


elphant1 = Elphant('大象')
haier = Refrigerator() 实例化冰箱类
elphant1.open(haier)  调用大象类,并且将实例化的冰箱类名传进去

依赖关系:将一个类的对象或者类名传到另一个类的方法使用

2.2 关联,聚合,组合关系

其实这三个在代码上写法是一样的. 但是, 从含义上是不一样的.

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

2. 聚合关系. 属于关联关系中的一种特例. 侧重点是xxx和xxx聚合成xxx. 各自有各自的声明周期. 比如电脑. 电脑里有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体

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

 

关联关系

class Boy:
    def __init__(self,name,girlFriend=None):
        self.name = name
        self.girlFriend = girlFriend

    def have_a_diner(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('日天')
b.have_a_diner() # 此时是单身狗

# 突然有一天，日天牛逼了
b.girlFriend = '如花'
b.have_a_diner()  #共进晚餐
复制代码
复制代码
# wusir 生下来就有女朋友 服不服
gg = Girl('小花')
bb = Boy('wusir', gg)
bb.have_a_diner()

# 结果嫌他有点娘，不硬，分了
bb.girlFriend = None
bb.have_a_diner()

 

组合：将一个类的对象封装到另一个类的对象的属性中，就叫组合。

咱们设计一个游戏人物类，让实例化几个对象让这几个游戏人物实现互殴的效果。

class Gamerole:
    def __init__(self,name,ad,hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self,p1):
        p1.hp -= self.ad
        print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp))
gailun = Gamerole('盖伦',10,200)
yasuo= Gamerole('亚索',50,80)

#盖伦攻击亚索
gailun.attack(yasuo)
# 亚索攻击盖伦
yasuo.attack(盖伦)

 

但是这样互相攻击没有意思，一般游戏类的的对战方式要借助武器，武器是一个类，武器类包含的对象很多：刀枪棍剑斧钺钩叉等等，所以咱们要写一个武器类。

class Gamerole:
    def __init__(self,name,ad,hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self,p1):
        p1.hp -= self.ad
        print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp))
        
    def equip_weapon(self,wea):
        self.wea = wea  # 组合：给一个对象封装一个属性改属性是另一个类的对象
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 - p1.ad
        print('%s 利用 %s 攻击了%s,%s还剩%s血'
              %(p1.name,self.name,p2.name,p2.name,p2.hp))


# 实例化三个人物对象：
barry = Gamerole('太白',10,200)
panky = Gamerole('金莲',20,50)
pillow = Weapon('绣花枕头',2)

# 给人物装备武器对象。
barry.equip_weapon(pillow)

# 开始攻击
barry.wea.weapon_attack(barry,panky)

上面就是组合，只要是人物.equip_weapon这个方法，那么人物就封装了一个武器对象，再利用武器对象调用其类中的weapon_attack方法。