类与类的组合

方式一：定义时的组合，实现一个类调用另一个类的属性，达到代码重用的目的；

• 定义一个实例的方法的变量接收另一个类的对象
• 注意：接收的这个类的参数必须与被接收的类的参数一一对应；

方式二：传参时的组合，实现一个类调用另一个类的属性，达到代码重用的目的； 原理与方式一样的！！！

• 在给一个类的实例对象参数传值时，将另一个类的对象传给它；
• 接收值对象的类的参数与传过来的对象的类的参数也是要一一对应；

方式三：不同对象的交互，实现一个类的不同对象的属性的互换；（这个方式有点绕哦）

• 这个类里定义一个方法，这个方法定义一个参数接收实例对象，实例一个实例对象与另一个实例对象数据的互换；
• 其实，可以直接调用对象属性的方式实现同样的效果，还更简单！！
  案例详见：ex41f.py

# 方式一：定义时的组合，实现一个类调用另一个类的属性，达到代码重用的目的
class BirthDate:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
class Person:
    def __init__(self, name, year, month, day):      # 定义这个类的属性变量必须传进来的参数(类BirthDat的参数)完全对应
        self.name = name
        self.birthdate = BirthDate(year, month, day) # 定义类的实例对象属性变量ot，让其值等于上面定义的BirthDate类，形成类与类的组合；
                                                     # 这里的birthdate相当于[year, month, day]，一次传三个参数，也一次传一个参数，传三次

P = Person('Lyon', 2000, 1, 1)
print(f"{P.name}'s birthdate is {P.birthdate.year} year {P.birthdate.month} munth {P.birthdate.day} day!")
# 相当于以下语句
B = BirthDate(2000, 1, 1)
print(f"{P.name}'s berthdate is {B.year} year {B.month} munth {B.day} day!")  # 这里调用了两个对象P和B

# 方式二：传参时的组合，实现一个类调用另一个类的属性，达到代码重用的目的

class BirthDate:
    def __init__(self, year, month, day): # 定义类的实例对象的属性参数，有以下三个参数
        self.year = year
        self.month = month
        self.day = day

class Person:     # 定义类的实例对象的属性参数，有以下二个参数
    def __init__(self, name, birthdate):
        self.name = name
        self.birthdate = birthdate

p = Person('Lyon', BirthDate(2002, 2, 2)) # 在实例化传参时，将BirthDate类及参数BirthDate(2000, 1, 1)传给Person类的实例对象的birthdate参数
print(f"{p.name}'s birthdate is {p.birthdate.year} year {p.birthdate.month} munth {p.birthdate.day} day!")
# 相当于以下语句
B = BirthDate(2002, 2, 2)
print("{}'s birthdate is {} year {} munth {} day!".format(p.name, B.year, B.month, B.day))  # 这里调用了两个对象P和B

# 方式三：不同对象的交互，实现一个类的不同对象的属性的互换（这个方式有点绕哦）

class Person:  # 定义的一个Person类
    def __init__(self, name):  # 定义Person类实例属性
        self.name = name       # Person类的实例对象有一个属性参数name

    def attack(self,per):      # 定义Person类的方法，该方法的实例对象有一个per参数
                               # 注意：这个参数必须是一个带有name属性的类的对象，不然下面的per.name就是错的
        print(f"{self.name} attacked {per.name}!")   # 这里调用了参数per的name属性

lyon = Person("Lyon")          # 实例化，创建lyon对象
kenneth = Person("kenneth")    # 实例化，创建kenneth对象
lyon.attack(kenneth) # 对象交互：调用lyon对象的attach方法，并给这个方法传入一个对象kenneth，
# 执行 print(f"{self.name} attacked {per.name}")时，相当于下面语句！
print(f"{lyon.name} attacked {kenneth.name}!")

#下面我们换一种写实现上面的例子

class Person:     # 定义类的实例对象的属性参数，有以下二个参数
    def __init__(self, name, year, month, day):
        self.name = name
        self.year = year
        self.month = month
        self.day = day

    def BirthDate (self, Bth): # 定义Person类的方法，该方法的实例对象有一个per参数
                               # 注意：这个参数必须是一个带有year/month/day属性的类的对象，不然下面的语句就是错的
                               # 这个方法功能是：将对象的属性与其参数Bth（另一个对象）给对应起来，实现了对象之的数据互换
        print(f"{self.name}'s birthdate is {Bth.year} year {Bth.month} munth {Bth.day} day!")

Lyon1 = Person("Lyon1", 2004, 4, 4)
Lyon2 = Person("Lyon2", 2003, 3, 3)
Lyon1.BirthDate(Lyon2)
Lyon2.BirthDate(Lyon1)

# 有点绕，其实也通过下面的语句实现相同的效果：
print(f"{Lyon1.name}'s birthdate is {Lyon2.year} year {Lyon2.month} munth {Lyon2.day} day!")
print(f"{Lyon2.name}'s birthdate is {Lyon1.year} year {Lyon1.month} munth {Lyon1.day} day!")