Python3.x基础学习-类--多继承、多态


多继承


一个子类继承多个父类,就是多继承,并且拥有所有父类的属性和方法例如:孩子会继承父亲和母亲的特征

如果子类和父类中有相同的方法,就会调用子类中的方法如果不同的父类中存在有相同的方法名称,子类对象调用的时候会调用哪个父类中的方法呢?python 会根据MRO(method resolution order) 方法解析顺序列表进行查找。
class Dog:
    def eat(self):
        print("吃骨头")

class God:
    def eat(self):
        print("吃上帝")

class Thing(God,Dog):
    pass

thing = Thing()
thing.eat()
print(Thing.__mro__)

# 吃上帝
# (<class ‘__main__.Thing‘>, <class ‘__main__.God‘>, <class ‘__main__.Dog‘>, <class ‘object‘>)
MRO列表并遵循如下三条准则:1.子类会先于父类被检查2.多个父类会根据他们在列表中的顺序进行检查3.如果对下一个类中有两个合法的选择,选择第一个父类
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        print("----B----")

class C(A):
    def func(self):
        print("----B-----")

class D(B,C):
    pass

d = D()
d.func()

print(D.__mro__)
print(D.mro())

# ----B----
# (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
# [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
多继承中super本质不是直接查找父类,而是根据调用节点的广度优先顺序执行的练习:创建 A、B、C、D 类,D 类继承 B,C 类,B 类继承 A 类,C 类继承 A 类。在每个方法中都调用 super().func()方法,查看执行顺序。
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(B,C):
    def func(self):
        super(D, self).func()
        print("----D-----")

d = D()
d.func()   # 继承顺序 D-->B-->C-->A

#结果:A,C,B,D
print(D.__mro__)
print(D.mro())
# (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
# [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
如图,B 继承 A, C 继承 A, D 继承 B 和 C。深度优先遍历是从 D 开始往上搜索到 B,若 B 没有数据,则继续往上搜索到 A;广度优先遍历是从 D 开始往上搜索到 B,若 B 没有数据,则搜索和 B 同级的 C 里的数据,若同级的 C 里还是没有数据,再继续往上搜索到 A 。Tips:py2 经典类是按深度优先来继承的,新式类是按广度优先来继承的。           py3 经典类和新式类都是统一按广度优先来继承的
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(B):
    def func(self):
        super(D, self).func()
        print("----D-----")

class E(C):
    def func(self):
        super(E, self).func()
        print("----E-----")

class F(D, E):
    def func(self):
        super(F, self).func()
        print("----F-----")

f = F()
f.func()   # 继承顺序 D-->B-->C-->A

# ----A----
# ----C-----
# ----E-----
# ----B----
# ----D-----
# ----F-----
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(C):
    def func(self):
        super(D, self).func()
        print("----D-----")

class E(B):
    def func(self):
        super(E, self).func()
        print("----E-----")

class G(B):
    def func(self):
        super(G, self).func()
        print("----G-----")

class H(A):
    def func(self):
        super(H, self).func()
        print("----H-----")

class F(D, E,G,H):
    def func(self):
        super(F, self).func()
        print("----F-----")

f = F()
f.func()

# ----A----
# ----H-----
# ----B----
# ----G-----
# ----E-----
# ----C-----
# ----D-----
# ----F-----
class A1: pass
class A2: pass
class A3: pass
class B1(A1,A2): pass
class B2(A2): pass
class B3(A2,A3): pass
class C1(B1): pass
class C2(B1,B2): pass
class C3(B2,B3): pass
class D(C1, C2, C3): pass

print("从D开始查找:")
for s in D.__mro__:
    print(s)

# 从D开始查找:
# <class ‘__main__.D‘>
# <class ‘__main__.C1‘>
# <class ‘__main__.C2‘>
# <class ‘__main__.B1‘>
# <class ‘__main__.A1‘>
# <class ‘__main__.C3‘>
# <class ‘__main__.B2‘>
# <class ‘__main__.B3‘>
# <class ‘__main__.A2‘>
# <class ‘__main__.A3‘># <class ‘object‘>

多态

面向对象三大特性: 封装、继承、多态

 1.封装:屏蔽提供细节,但提供调用方式,将功能封装成一个整体,提供简单的调用方式 2.继承:可以拥有另一个类的方法和属性 3.多态:让某个类呈现多种形态

实现多态的三个条件: 1.必须存在继承关系 2.重写目标方法  3.使用子类对象调用父类方法

定义人类,可以跳舞,可以玩,在玩的过程跳舞实现多态,老年人跳广场舞
class Person:
    def dance(self):
        print(‘跳舞‘)

    def play(self):
        self.dance()  #old.dance()

class Oldman(Person):
    def dance(self):
        print("跳广场舞")

old = Oldman()
old.play()

per = Person()
per.play()




原文地址:https://www.cnblogs.com/johnsonbug/p/12708027.html

时间: 04-15

Python3.x基础学习-类--多继承、多态的相关文章

【代码笔记】Java基础:类的继承(构造器)

在Java中,创建对象的格式为: 类名 对象名 = new 类名(): 如: 1 JFrame jf = new JFrame(); 一个对象被创建出来时,经常要先做一些事这个对象才能正常使用,也可以说是准备工作,比如给这个对象赋些初始值,或者先运行一些别的方法.这时候就需要一个“构造器”用于: 构造对象 初始化属性这样,把那些在创建时要做的事写在构造方法里,每次创建就会被执行一遍. 我们常见的一种Java格式: public 返回类型 方法名(参数){ } 如: 1 public void s

python面向对象编程基础II(类的继承)

继承一个类 继承的好处: 1.复用已有代码 2.自动拥有现有类的所有功能 3.只需要编写缺少的功能 如果已经定义了Person类,需要定义新的Student和Teacher类时,可以直接从Person类继承: class Person(object): def __init__(self, name, gender): self.name = name self.gender = gender 定义Student类时,只需要把额外的属性加上,例如score: class Student(Pers

Python学习-类的继承

1 继承: 2 #python2 经典类是按深度优先来继承的,新式类是按广度优先来继承的 3 #python3 经典类和新式类都是按广度优先来继承的 4 5 6 7 #经典类:class People: 8 class People(object): #这个是新式类,多继承的时候有了改变 9 10 def __init__(self, name, age): 11 self.name =name 12 self.age = age 13 14 15 def eat(self): 16 print

基础回顾:get方法和set方法(类的继承多态)

基础回顾:get方法和set方法 定义类成员变量时,可以在@interface中定义,也可以在@implementation中定义: 在@interface中声明,成员变量的状态是受保护的,即“@protected”: 在@implementation中声明,成员变量的状态是私有的,即“@private” 在类的外面,是无法直接访问成员变量的,只有将成员变量修改为@public时,才可以外部访问. 使用@public时,访问成员变量使用“->”,如: time->hour=25; 但使用@pu

Java基础学习之final和多态及类型转换

final关键字: final关键字是最终的意思,可以修饰类,成员变量,成员方法. ?    修饰类,类不能被继承 ?    修饰变量,变量就变成了常量,只能被赋值一次. ?    修饰方法,方法不能被重写 final关键字面试题 ?    final修饰局部变量 在方法内部,该变量不可以被改变,只可以赋值一次. 在方法声明上,分别演示基本类型和引用类型作为参数的情况 基本类型,是值不能被改变 引用类型,是地址值不能被改变.对象在堆内存的值是可以改变的. ?    final修饰变量的初始化时机

Python学习 Day 8 继承 多态 Type isinstance dir __slots__

继承和多态 在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Base class.Superclass). >>> class Animal(object):#名为Animal的class defrun(self): print'Animal is running...' >>> class Dog(Animal):#从Animal类继承 pass

黑马程序员---Objective-C基础学习---类、对象、方法相关知识笔记

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 类.对象.方法相关知识笔记 Objective-C相对于C语言有了面向对象的特性,但是ObjC又没有其他面向对象语言那么多语法特性,ObjC本身对面向对象进行了精简.下面是一些相关知识笔记. 类定义 成员变量 方法和属性 self关键字 类定义 在C#.Java等其他高级语言中定义一个类是相当简单点的,直接一个关键字class加一对大括号基本就完成了,但是在ObjC中类的定义相对变化比较大.现

JS面向对象基础篇(封装 继承 多态)

首先我们要创建一个对象,我们可以利用javascript的语法特征,以类的思想来创建对象 一:封装 (1)原始方法,代码如下 <script> var obj=new Object(); obj.name='Tom'; //给对象添加属性 obj.sex=22; obj.showName=function(){ //给对象添加方法 alert(this.name); } obj.showAge=function(){ alert(this.age); } obj.showName(); //'

c#基础知识 类的继承 修饰符

子类 父类 单继承 所有类都是 class Stusent :Person{ //student继承person类 } 继承 子类自动从父类那里继承所有的 字段.方法.属性.索引器等成员作为自己的成员 处理继承父类的成员外,子类还可以 添加新的成员 隐藏或修改父类的成员 class A{ public int a: } class B:A{ new public int a; } public公共  private私有 static的字段.方法.属性是属于整改类的,直接通过类型访问

Java基础 -- 复用类(组合和继承)

复用类有两种实现方式. 在新的类中产生现有类的对象,由于新的类是由现有类的对象所组成,所以这种方法称之为组合. 采用继承实现. 一  组合语法 下面创建两个类WaterSource和SprinklerSystem.其中SprinklerSystem中包含WaterSource的对象引用. class WaterSource { //如果定义时没有初始化,则基本类型会被自动初始化为0,对象引用初始化为Null private String s; WaterSource(){ System.out.