多继承与多态（鸭子模型）

多继承

顾名思义:就是一个子类中可以有多个父类,比如一个孩子有一个爸爸,还有一个妈妈

from  child import Child

def main():
    c = Child(300, 100)
    print(c.money, c.faceValue)
    c.play()
    c.eat()
    #注意:如果多个父类中的方法名相同,默认调用的是子类括号中排前面的父类中的方法
    #此时调用的是Father中func方法
if __name__ == "__mian__":
    main()

class Father(object):
    def __init__(self, money):
        self.money = money
    def play(self):
        print("play")
    def func(self):
        print("Father")

class Mother(object):
    def __init__(self, faceValue):
        self.faceValue = faceValue
    def eat(self):
        print("eat")
    def  func(self):
        print("Mother")     

from father import Father
from mother import Mother

class Child(Father, Mother):
    def __init__(self, money, faceValue):
        #注意:分别调用各个父类中的构造方法
        Father.__init__(self, money)
        Mother.__init__(self, faceValue)
        #子类中同样可以有自己独有的特性
  

总结:

1. 子类可以从多个父类中继承属性和方法
2. 一个父类可以有多个子类
3. 一个子类可以有多个父类

当我们使用多继承的时候,若父类中同时出现相同的方法,
这时候会优先选择继承元组中写在前面的那个

class Father():
    def __init__(self,name,sex,age,money):
        self.name = name
        self.sex = sex
        self.age = age
        self.money = money
        print("爸爸的构造方法被调用了...")

    def makemoney(self):
        print("赚钱特别厉害哦...")


    def __dance(self):          #私有方法
        print("会跳街舞哦....")

    def aa(self):            #将私有方法打开一个缺口,使子类可以调用
        self.__dance()


class Monther():
    def __init__(self,name,sex,age,facevalue):
        self.name = name
        self.sex = sex
        self.age = age
        self.facevalue = facevalue
        print("妈妈的构造方法被调用了...")

    def spendMoney(self):
        print("很会花钱哦...")

    def dance(self):
        print("会跳肚皮舞哦...")



class Child(Father,Monther):      #继承属性和方法先后顺序,先父亲母亲
    def __init__(self,name,age,sex,money,facevalue):
        Father.__init__(self,name,sex,age,money)
        Monther.__init__(self,name,sex,age,facevalue)

if __name__ == "__main__":
    child = Child("xiaoming","boy",18,10000000,90)
    print(child.name)
    print(child.money)
    print(child.facevalue)
    child.makemoney()
    child.spendMoney()
    child.dance()
    child.aa()   # 若该语句注释,则不出现 "会跳街舞哦...."

	# 打印结果
	爸爸的构造方法被调用了...
	妈妈的构造方法被调用了...
	xiaoming
	10000000
	90
	赚钱特别厉害哦...
	很会花钱哦...
	会跳肚皮舞哦...
	会跳街舞哦....

多态 --鸭子模型

多态是指一类事物的有多种状态【一个抽象类有很多子类，因而多态的概念依赖于继承。】

1. 序列有多种形态：字符串，列表，元组
2. 动物有多中形态：猫，狗

在代码中,多态依赖于继承而存在的
当我们继承之后,我们重写复写父类中方法,
这时候再进行调用子类的时候,自动调用子类中的方法.

python中不存在多态，【python动态语言】
python中不存在真正的多态,为了迎合面向对象语言的三大特征,
所以有时候也叫多态

鸭子模型:如果有一只鸟,走路像鸭子,叫声像鸭子,我们就称这只鸟为鸭子.
使用鸭子模型的时候,我们 !!!不关注它的数据类型,关注是属性以及方法.!!!
原因:python是属于动态数据类型的语言,
无论任何类型的参数我们都可以直接传递,无需考虑类型

定义父类：

class Animal(object)：
	def run(self):
        print("Animal is running....")

定义子类：

class Dog(Animal):
    def run(self):
        print("Dog is running...")
    
    def eat(self):
        print("Eating meat....")

继承的第二个好处是，我们可以在自己需要的时候，对我们的代码进行改进。当子类与父类都存在相同的run()方法的时候，子类中的run()覆盖了父类中的run(),在代码运行的时候，总会调用子类中的run().

这时候我们就获取了继承的另外一个好处：多态。

若要理解多态，我们首先要对数据类型再进行说明，我们定义一个class的时候，其实就是定义了一种数据类型。

a = list() #a是list类型
b = Animal() #b是Animal类型
c = Dog() #c是Dog类型

判断一个变量是否是某个类型们可以使用instance()来判断

>>>isinstance(a,list)
True
>>>isinstance(b,Animal)
True
>>>isinstance(c,Dog)
True
#c不仅是Dog还是Animal
>>>isinstance(c,Animal)
True

在继承的关系中，如果一个实例的数据类型是某个子类，那么它的数据类型也可以被看做是父类。

多态的优点：

class Animal(object)：
	#def run(self):
     #   print("Animal is running....")
     
    @staticmethod
    def run2(Animal):
        Animal.run()
        
class Dog(Animal):

    def run(self):
        print('Dog is running...')

class Cat(Animal):

    def run(self):
        print('Cat is running...')

Animal.run2(Dog())
Animal.run2(Cat())
#结果
Dog is running...
Cat is running...

新增子类的时候我们不需要对我们的run2()做任何的修改，任何依赖Animal作为参数的函数都可以不加修饰的正常的运行。

多态的优点就是，当我们需要传入Dog，Cat，…时我们只需要接收Animal类型的即可,因此，传入的类型只要是Animal类或者是子类，就会自动调用实际类型的run()方法，这就是多态的意思。

获取对象属性

使用type()来判断对象类型

>>>type(123)

若是一个变量指向函数或者是类，依然可以使用type()判断。

isinstance()可以判断一个对象是否属于某种类型

>>> a = Animal()
>>> b = Dog
>>> isinstance(a,Animal)
True
>>> isinstance(b,Animal)
True

还可以判断一个变量是否是某些类型中的一种，比如下面的代码：

>>> isinstance([1,2,3],(list,tuple))
True

使用dir()函数可以获取一个对象的所有的属性和方法，它返回一个包含字符串的list

>>> dir(a)