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

2022-09-12 13:04:16 阅读：246 来源： 互联网

标签：name python self 多态 class 面向对象 print age def

一、类的继承

（一）、父类与子类

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

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

实例

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 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)

标签：name,python,self,多态,class,面向对象,print,age,def
来源： https://www.cnblogs.com/L2119/p/16685919.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

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