python面向对象的组合和多态、多态性

组合

组合：一个对象拥有一个属性，该属性值是另外一个对象

解决类与类之间的冗余问题：
  1. 继承： 满足什么是什么的关系
  2. 组合： 满足什么有什么的关系

    比如bar中有n，但我Foo想调n，这是就用到了组合，obj2赋值给obj1.z，然后obj1就可以调用n
      class Foo:
          x = 1
          def __init__(self, m):
              self.m = m

          def func1(self):
              return self.m

      class Bar():
          y = 2
          def __init__(self, n):
              self.n = n

          def func2(self):
              return  self.n

      obj1 = Foo(10)
      obj2 = Bar(20)
      obj1.z = obj2
      print(obj1.z.n)

多态与多态性

多态：一种事物的多种状态
1.水：固定水，液态水，水蒸气
2.动物：人， 狗， 猪

继承：解决冗余问题
  多态类中继承：不是让子类遗传父类的属性和方法，  是用来给子类定制标准的
  多态带来的特性：在不用考虑对象数据类型的情况下，直接调用对象的方法

     制定子类的标准
          import abc  # abstract => 抽象
        # 该类已经为抽象类了，是用来给子类定制标准的
        class Animal(metaclass=abc.ABCMeta):
            @abc.abstractmethod
            def speak(self):
                pass

            @abc.abstractmethod    #修饰符
            def run(self):
                pass

        class People(Animal):
            def speak(self):
                pass

        class Dog(Animal):
            def speak(self):
                pass


        class Pig(Animal):
            def speak(self):
                pass
            pass

        obj1 = People()
        obj2 = Dog()
        obj3 = Pig()

        obj1.speak()
        obj2.speak()
        obj3.speak()
     约定熟成的：也就是鸭子类型
       Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
         python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象
           也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。
        class People():
            def speak(self):
                pass

        class Dog():
            def speak(self):
                pass

        class Pig():
            def speak(self):
                pass
         
        obj1 = People()
        obj2 = Dog()
        obj3 = Pig()

        obj1.speak()
        obj2.speak()
        obj3.speak()