【面向对象编程】(3) 类之间的交互，依赖关系，关联关系

各位同学好，今天和大家分享一下面向对象编程中，类之间的交互，类之间的依赖关系和关联关系。有不明白的可见前一章节：https://blog.csdn.net/dgvv4/article/details/122297834?spm=1001.2014.3001.5501

1. 类之间的交互

定义两个类，通过在每个类中定义的方法来进行实例之间的交互。

以人打狗，狗咬人为例。在 Dog 类中定义了一个 bite 函数，第一个参数 self 是该类的实例化对象本身，第二个参数 person 是另一个类的实例化对象，其中 self.attack_val 调用的是该类的实例的 attack_val 属性的值，person.life_val 调用的是 person 实例的 life_val 属性的值。计算后直接改变了 person.life_val 对应的值。

#（1）定义第一个类
class Dog:
    
    attack_val = 30  # 类属性，攻击力
    
    # 初始化，指定传入的属性值的数据类型
    def __init__(self, name:str, breed: str, life_val=100):
        
        # 当传入的属性值不满足条件就报错，报错内容是逗号后面的
        assert life_val >= 0, f"life_val {life_val} is smaller than 0"
   
        # 分配属性
        self.name = name
        self.breed = breed
        self.life_val = life_val
        
    # 定义类方法，与第二个类的交互
    def bite(self, person):  # 传入prison实例 
        
        # 改变实例'person'的生命值 
        person.life_val -= self.attack_val
    
#（2）定义第二个类
class Person:
    
    attack_val = 50  # 定义类属性，攻击力
    
    # 初始化，指定传入的属性值的数据类型
    def __init__(self, name:str, sex:str, life_val=100):
        
        # 当传入的属性值不满足条件就报错，报错内容是逗号后面的
        assert life_val >= 0, f"life_val {life_val} is smaller than 0"
 
        # 分配属性
        self.name = name
        self.sex = sex
        self.life_val = life_val
    
    # 定义类方法，和第一个类之间的交互
    def attack(self, dog):  # 传入第一个类实例dog
        
        # 改变对象dog的life_val属性
        dog.life_val -= self.attack_val
        
#（3）对两个类分别实例化，传入初始化的属性值
person = Person('小强', 'male', 100)
dog = Dog('老黑', '柯基', 60)

#（4）两个类之间的交互
# 实例'person'攻击实例'dog'
person.attack(dog)  # 第一个参数self是实例person，只需要传入第二个参数
print('dog life value: ', dog.life_val)  # 60-50 = 10

# 实例'dog'攻击实例'person'
dog.bite(person) # 第一个参数self默认是实例dog
print('person life value:', person.life_val) # 100-30 = 70

---

2. 类之间的依赖关系

一个类可以调用另一个类中的属性。在初始化时，在一个类中传入第二个类的实例化对象，这样的话，第一个类可以调用第二个类中的属性。

如下面代码中，在 person 类初始化中传入一个属性 weapon，该属性是一个类实例化对象。在分配属性时接收这个对象 self.weapon = weapon，这样的话，Person 类的实例化对象 person 就可以调用 weapon 对象的所有属性。其中 self.weapon.name 就是通过实例 person 调用实例weapon，再调用它的属性 name，得出结果。

#（1）定义类
class Person:   
    
    life_val = 100  # 类属性

    #（2）初始化，self为实例化对象
    def __init__(self, name:str, sex:str, life_val:int, weapon):  # weapon是另一个实例化对象
    
        # 分配属性
        self.name = name
        self.sex = sex
        self.life_val = life_val
        self.weapon = weapon   # 依赖关系，'person'实例可以调用'weapon'实例中的属性 
        self.claim()  # 在初始化时调用自己的方法
        
    # 定义类方法
    def claim(self):
        # 打印该类的相关信息
        print(f'{self.name} use {self.weapon.name}, the attack is {self.weapon.attack_val}')
        # 阿强 use gun, the attack is 90
        
#（3）定义第二个类
class Weapon:
    
    # 初始化，指定各个属性值的数据类型
    def __init__(self, name:str, attack_val:int):
        
        # 分配属性
        self.name = name
        self.attack_val = attack_val

#（4）类实例化
weapon = Weapon('gun', 90)  # 实例化Weapon类，传入属性值
person = Person('阿强', 'male', 100, weapon)  # 实例化person类，传入属性值，以及另一个实例化对象

---

3. 关联关系

两个类可以相互调用双方的属性。同样，两个类实例化对象都可以调用彼此的属性。

3.1 方法一：在属性分配时确定关系

在类的初始化时不传入另一个实例，而在分配属性时，设置一个属性存放该类实例化对象的关联对象，先将其设为None，self.opponent = None。完成类实例化对象之后，就可以将该属性指定为另一个对象，如：person1.opponent = person2 ，这样的话，实例 person1 就可以通过属性 opponent 调用实例 person2 中的所有属性。同理，需要将 person2.opponent = person1 才能完成两个实例之间的关联关系。

如：person2.opponent.name，就是通过实例 person2 调用其属性 opponent ，此时 person2.opponent 就是代表实例 person1，再调用其属性 name

解除关联关系的方法，同时将双方的 opponent 属性变成 None。

#（1）定义一个类
class Person:  

    life_val = 100  # 定义类属性    

    #（2）初始化，传入属性值，属性attack_val默认为10
    def __init__(self, name, age, attack_val=10):
        
        # 属性分配
        self.name = name
        self.age = age
        self.attack_val = attack_val
        
        #（3）用于关联两个对象，两个对象可以相互使用对方的属性
        self.opponent = None  # 因为第一个实例化没有关联对象，需要等所有实例化完成之后在修改        

#（4）类实例化对象，传入属性值
person1 = Person('阿强', 18, 50)
person2 = Person('阿珍', 30, 20)

#（5）将两个实例关联起来
person1.opponent = person2  # 实例person1可以使用实例person2的属性
person2.opponent = person1  # 实例person2可以使用实例person1的属性

#（6）打印结果
print(f"{person1.name} 's opponent is {person1.opponent.name}, her attack_val is {person1.opponent.attack_val}")
# 阿强 's opponent is 阿珍, her attack_val is 20
print(f"{person2.name} 's opponent is {person2.opponent.name}, his life_val is {person2.opponent.life_val}")
# 阿珍 's opponent is 阿强, his life_val is 100

#（7）解除两个实例之间的关联关系
# 将联系双方的属性值变成None
person1.opponent = None
person2.opponent = None

---

3.2 方法二：重写一个新类确定关联关系

在外部定义一个新的类 Relation，用于存放两个实例之间的关系。在初始化时，只需要定义一个空列表，代表两个实例之间不存在关联关系。定义两个方法用于确定关联关系和解除关系。

在定义的 Person 类中，初始化需要传入两个实例间的关系，用 relation 属性来接收它 self.relation = relation，初始为空，这样的话，就可以通过 relation 属性来调用 Relation 类中的所有方法。

确定关联关系 relation.make_couple(person1, person2)，通过 relation 实例调用 make_couple() 方法，该方法传入两个实例，以列表的形式将两个实例保存在 relation 实例的 couple 属性中。 其中，person1.relation.couple[1].name，是通过 person1 实例调用 person2 实例中的 name 属性的值。person1.relation 调用的是实例 relation，person1.relation.couple[1] 是调用的实例 person2

解除关系 relation.break_couple()，通过实例 relation 调用方法 break_couple()，将关系列表变为空。

#（1）统一在一个类中规定两个实例是否能相互调用对方的属性
class Relation:
    
    # 初始化
    def __init__(self):
        
        # 存放两个实例的关联状态
        self.couple = []

    # 定义方法，将两个实例传进来
    def make_couple(self, obj1, obj2):
        
        # 将两个实例保存到列表中
        print('生成关联关系')
        self.couple = [obj1, obj2]
    
    # 解除关联关系
    def break_couple(self):
        
        # 将列表清空
        print('解除关联关系')
        self.couple = []

#（2）定义类，如果两个实例之间是关联关系，那么相互之间可以使用对方的属性
class Person:
    
    life_val = 100
    
    # 初始化，将确定关系的实例输入
    def __init__(self, name, age, attack_val, relation):
        
        # 分配属性
        self.name = name
        self.age = age
        self.attack_val = attack_val
        self.relation = relation  # 将另一个实例作为本实例的属性

#（3）类实例化对象
relation = Relation()
person1 = Person('阿强', 18, 50, relation)
person2 = Person('阿珍', 30, 20, relation)
# 这里relation.couple还只是一个空列表

#（4）关联两个对象，相互使用对方的属性
relation.make_couple(person1, person2)

#（5）这时两个实例就可以相互调用对方的属性
print(f"{person1.name} 's opponent is {person1.relation.couple[1].name}, \
her attack is {person1.relation.couple[1].attack_val}")
# 阿强 's opponent is 阿珍, her attack is 20

#（6）一次性解除两个实例之间的关联关系
relation.break_couple()
# 或 person1.relation.break_couple()