python类的继承与多态的概念_Python 基础之面向对象类的继承与多态

一.继承

定义:一个类除了拥有自身的属性方法之外,还拥有另外一个类的属性和方法继承: 1.单继承2.多继承子类:一个类继承了另外一个类,那么这个类是子类(衍生类)父类:一个类继承了另外一个类,被继承的那个类是父类(超类,基类)object是所有的类的父类

1.单继承

#例:

class Human():

def eat(self):

print("远古人类打猎,吃猎物")

def sleep(self):

print("远古人类吃饱了就睡觉")

def __beat_doudou(self):

print("远古人类起来先打豆豆,再打猎")

#把要继承的类放到class定义类的这个括号里面写

(1)子类可以调用父类的公有成员(方法,属性)

#例:

class Man(Human):

pass

#实例化对象

obj = Man()

obj.eat()

(2)子类不可以调用父类私有成员(方法,属性)

#例:

class Woman(Human):

def myskill(self):

#调用父类公有方法

self.eat()

#不能够在子类里面调用父类私有方法

#self>__beat_doudou()

obj = Woman()

#obj.__beat_doudou() 私有的没法再类外调用

obj.myskill()

(3)子类可以改造父类的公有方法

子父继承之后,如果调用的成员子类里面有,优先调用子类的子类里面没有,就调用父类

#例:

class Children(Human):

#对eat方法进行改写

def eat(self):

print("小孩生下来只会喝奶")

obj = Children()

obj.eat()

2.多继承

(1)基本语法

#例:

class Father():

f_property = "风流倜傥,英俊潇洒"

def f_hobby(self):

print("喜欢跑步")

class Mother():

m_property = "沉鱼落雁,闭月羞花"

def m_hobby(self):

print("喜欢做菜")

#多继承:在括号里面用逗号,把多个父类隔开

class Daughter(Father,Mother):

pass

obj = Daughter()

print(obj.f_property)

obj.m_hobby()

(2)调用父类

class Father():

f_property = "风流倜傥,英俊潇洒"

def f_hobby():

print("喜欢跑步")

class Mother():

m_property = "沉鱼落雁,闭月羞花"

def m_hobby(self):

print("喜欢做菜")

class Son(Father,Mother):

#f_property = "子类的属性f_property"

#(1)通过类的方式调用父类的相关成员

def skill1(self):

#调用Father的f_hobby

Father.f_hobby()

#调用Mother中的m_property

print(Mother.m_property)

#(2)通过对象的方式调用父类的相关成员

def skill2(self):

#调用Father中的f_property

print(self.f_property)

#调用Mother中的m_hobby

self.m_hobby()

#(3)使用super调用父类的相关成员

def skill3(self):

# 调用Father中的f_property

#super() 一定调用的是父类的,区别于self

#print(super().f_property)

#super().f_hobby() error super() 调用的是绑定方法,默认传递self参数

super().m_hobby()

print("============")

obj = Son()

obj.skill1()

#obj.skill2()

obj.skill3()

#关于super的概念

(1)super本身是一个类,super()是一个对象,用于调用父类的绑定方法(2)super()只应用在绑定方法中,默认自动传递self对象(前提:super所在作用域存在self)(3)super用途:解决复杂的多继承调用顺序

3.菱形继承

#菱形继承就是广度优先算法的方式继承父类函数#例:下面是关于例1中的继承关系

Human

Man       Woman

Children

#例:

class Human():

pty = 111

def feelT(self):

print("远古人类天热了1")

print(self.pty)

print("远古人天冷了2")

class Man(Human):

pty = 222

def feelT(self):

print("现代男性天气热了3")

super().feelT()

print("现代男性天冷了4")

class Woman(Human):

pty = 333

def feelT(self):

print("现代女性天热了5")

super().feelT()

print("现代女性天冷了6")

class Children(Man,Woman):

pty = 444

def feelT(self):

print("小孩天热了7")

super().feelT()

print("小孩天冷了8")

obj = Children()

obj.feelT()

#c.f => 7

#M.f =>3

"""

#mro列表:通过c3算法,把所有的继承关系按照列表的顺序呈现

#语法:

#类.mro() => 继承顺序列表

[,

,

,

,

]super就是默认按照mro列表的顺序,依次调用用于解决多继承调用顺序混乱的问题

"""

lst = Children.mro()

print(lst)

#判断是否是子父关系[有血缘关系即可] issubclass

res = issubclass(Children,Man)

res = issubclass(Children,Human)

#满足一个条件,即返回真

res = issubclass(Children,(Man,Woman))

print(res)

#判断对象的类型, [有血缘关系即可] isinstance

res = isinstance(obj,Children)

res = isinstance(obj,Man)

res = isinstance(obj,(Human,Woman))

print(res)

二.多态(不同的对象)

不同的子类对象,调用相同的父类方法,产生不同的执行结果特征:继承  重写好处:在不改变代码的前提下,实现代码的复用,和不同的效果

#例:

class Soldier():

#攻击

def attack(self):

pass

#撤退

def back(self):

pass

#陆军

class Army(Soldier):

def attack(self):

print("[陆军]使用坦克进攻轰炸")

def back(self):

print("[陆军]使用军车进行撤退")

#海军

class Navy(Soldier):

def attack(self):

print("[海军]使用鱼雷攻击")

def back(self):

print("[陆军]开启防御鱼雷模式")

#空军

class Airforce(Soldier):

def attack(self):

print("[空军]炮弹袭击")

def back(self):

print("[空军]降落防空基地")

#实例化各个兵种,各就位准备

obj_army = Army()

obj_navy = Navy()

obj_airforce = Airforce()

lst = [obj_army,obj_navy,obj_airforce]

#等待将军下发命令

strvar = """

您好将军,下面是您的操作按钮:

1.全体出击

2.全体撤退

3.陆军出击,其他人撤退

4.退出程序

"""

sign = True

while sign:

print(strvar)

num = input("将军请下令:")

for i in lst:

if num == "1":

i.attack()

elif num == "2":

i.back()

elif num == "3":

if isinstance(i,Army):

i.attack()

else:

i.back()

elif num == "4" or num.upper() == "Q":

sign = False

break

else:

print("风太大,我听不到")

break