95_组合（类的套娃，和高阶函数概念差不多）

99.组合

  “is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a” 关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
  “has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。” has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

(类的套娃，可以理解为高阶函数的 类的实现。高阶函数是 函数作为参数，这里是 类的实例作为参数。)

两种方式都可以起到代码 复用的作用

使用继承实现代码的复用

# 使用继承实现代码的复用


class A1:

    def say_a1(self):
        print("a1,a1,a1")


class B1(A1):
    pass


b1 = B1()
b1.say_a1()


In [17]: class A1:
    ...:
    ...:     def say_a1(self):
    ...:         print("a1,a1,a1")
    ...:
    ...:
    ...: class B1(A1):
    ...:     pass
    ...:
    ...:
    ...: b1 = B1()
    ...: b1.say_a1()
a1,a1,a1

同样的效果，使用组合实现代码的复用

class A2:
    def say_a2(self):
        print("a2,a2,a2")


class B2:
    def __init__(self, a):
        self.a = a


a2 = A2()  # 把'A2()'类 的实例 赋值给 'a2'
b2 = B2(a2) # 将 A2 的实例 a2 当做参数 传递给 B2 类 得到 b2 实例
# b2 实例就有了 一个  属性 a ，也就是 a2 是 b2 的属性   
# a2 的 属性 或者 方法  。 say_a2 就这样获取到了。
b2.a.say_a2()



In [18]: class A2:
    ...:     def say_a2(self):
    ...:         print("a2,a2,a2")
    ...:
    ...:
    ...: class B2:
    ...:     def __init__(self, a):
    ...:         self.a = a
    ...:
    ...:
    ...: a2 = A2()  
    ...: b2 = B2(a2)
    ...: b2.a.say_a2()
a2,a2,a2

测试 has-a 关系，使用组合

# 测试 has-a 关系，使用组合



class MobilePhone:
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen


class CPU:
    def calculate(self):
        print("算你个12345")
        print("cpu对象：", self)


class Screen:
    def show(self):
        print("显示一个好看的画面，亮瞎你的钛合金大眼")
        print("screen对象：", self)


m = MobilePhone(CPU(), Screen())
m.cpu.calculate()
m.screen.show()


# 这种所谓 组合 关系。 其实本质就是 套娃嘛 
# 将 实例 当做参数 传递给 一个 类
# 这个类的 实例 的属性 就变成了 传递进去的 参数。 也就是 传递进去的实例对象
# 然后 通过 这个类的属性  得到 实例对象。 再 通过实例 对象 ，访问他自己的属性和方法 。

In [21]: m = MobilePhone(CPU(), Screen())

In [22]: m.cpu.calculate()
    ...: m.screen.show()
算你个12345
cpu对象： <__main__.CPU object at 0x052BA490>
显示一个好看的画面，亮瞎你的钛合金大眼
screen对象： <__main__.Screen object at 0x052BA930>