python面向对象之二（类的继承、类的多态）

一、类的继承

（一）、父类与子类

父类：被继承的类，子类继承父类后，会继承父类里面所有的属性（数据属性&实例属性）以及方法

子类：继承其他的类，子类继承父类后，能够继承父类里面所有的方法以及属性，当然也可以调用

实例

class Persion(object):
    city=’xian’
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print(‘my name is {name},and my age is {age}’.format(
            name=self.name,age=self.age))

class Student(Persion):
    def __init__(self,name,age,score):
        #子类继承父类的实例属性
        Persion.__init__(self,name,age)                
        self.score=score

    def info(self):
        print(‘my name is {name},and my age is {age},and my score is {score},’
              ‘and my city is {city}’.format(
            name=self.name,age=self.age,score=self.score,city=self.city))
        print(‘子类调用父类的方法输出结果：/n’)
        self.show()

stu=Student(‘wuya’,18,90)
stu.info()
print(stu.city)       

   

（二）、原则

继承的N个原则：
1、子类可以继承N个父类，但是建议不要超过两个，最多两个
2、山下原则》》》如果子类没有重写父类的方法，那么使用的是上下原则
  A、如果子类没重写父类的方法，调用父类的方法，输出的结果是父类里面方法的输出结果
  B、如果子类重写了父类里面的方法，那么调用该重写的方法，输出的结果是子类里面方法的输出结果
3、从左到右原则：一个子类继承多个父类，那么调用方法后，从左到右按线性的方式（找到满足的不找了）寻找
方法重写：子类重写了父类里面的方法。重写的目的是父类的方法没有办法满足子类的需求，那么就会重写

上下原则：

①、方法重写的
class Persion(object):
    city=’xian’
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print(‘my name is {name},and my age is {age}’.format(
            name=self.name,age=self.age))                       

class Student(Persion):
    def __init__(self,name,age,score):
        Persion.__init__(self,name,age)                         

self.score=score

    def info(self):
        print(‘my name is {name},and my age is {age},and my score is {score},’
              ‘and my city is {city}’.format(
            name=self.name,age=self.age,score=self.score,city=self.city))
    def show(self):
        print(‘我是子类的show method’)              
stu=Student(‘wuya’,18,90)
stu.info()
stu.show()                                        

 

②、方法未重写的

class Persion(object):
    city=’xian’
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print(‘my name is {name},and my age is {age}’.format(
            name=self.name,age=self.age))                       

class Student(Persion):
    def __init__(self,name,age,score):
        Persion.__init__(self,name,age)                         

self.score=score

    def info(self):
        print(‘my name is {name},and my age is {age},and my score is {score},’
              ‘and my city is {city}’.format(
            name=self.name,age=self.age,score=self.score,city=self.city))          
stu=Student(‘wuya’,18,90)
stu.info()
stu.show()  

 

从左到右原则：

class A(object):
    def show(self):
        print(‘this is A’)

class B(object):
    def show(self):
        print(‘this is B’)

class C(A,B):
    pass                  

c=C()                      
c.show()                  

 

（三）、继承中常见的错误日志

class A(object):
    def show(self):
        print(‘this is A’)

class B(A):
    def show(self):
        print(‘this is B’)

class C(A,B):
    pass

c=C()
c.show()

 

（四）、继承的原理

所以在Python中，基于MRO的解析顺序规则，就会从左到右开始查找基类，如果找到第⼀个匹配的属性类，就会停⽌查找，如果没有，那就继续查找，直到查找到符合要求的为⽌。MRO其实就是通过⼀个C3线性化算法来实现
的，它的核⼼思想为：
1、⼦类会优先于⽗类检查
2、多个⽗类会根据它们在列表中的顺序被依次检查
3、如果对下⼀个类存在两个合法的选择，只能选择第⼀个

class A(object):
    def show(self):
        print(‘this is A’)

class B(object):
    def show(self):
        print(‘this is B’)

class C(A,B):
    pass

c=C()
print(C.mro())
c.show()

 

（五）、java与python继承的区别

Java是单继承的，而python是多继承的，当然不建议超过两个

（六）、python2余python3的查找区别

把Python2的类叫经典类，Python3的类叫新式类，其实在Python2中，多个类的继承算法叫深度优先，⽽Python3叫⼴度优先

演示python3的继承查找流程
class A(object):
    def show(self):
        print(‘A’)

class B(A):
    def show(self):
        print(‘B’)

class C(A):
    def show(self):
        print(‘C’)

class D(B,C):
    pass

obj=D()
print(D.mro())

 

结果：python2中的结果是D,B,A,C,object   python3是D,B,C,A,object

二、类的多态

（一）、优势

1、增加了持续的灵活性

2、增加了持续的额外扩展的功能

（二）、一切皆对象
name=’wuya’

def func():
    print(‘hello word’)

class Person(object):
    def show(self):
        print(‘This Is A Class’)

obj1=name
print(obj1)     

obj2=func
obj2()                

obj3=Person
obj3().show()       

 

（三）、鸭子类型

在Python⾥⾯，所谓鸭⼦类型就是指“如果看起来像，叫声像⽽且⾛路起来像鸭⼦，那么它就是鸭⼦”。

class Animal(object):
    def talk(self):
        print(‘动物会叫’)

class Cat(Animal):
    def talk(self):
        print(‘猫也是会叫的’)

class Dog(Animal):
    def talk(self):
        print(‘狗也是会叫的’)

def func(animal):
    animal.talk()

cat=Cat()
func(animal=cat)
dog=Dog()
func(animal=dog)