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():
    #对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() => 继承顺序列表
[<class ‘__main__.Children‘>,
<class ‘__main__.Man‘>,
 <class ‘__main__.Woman‘>,
 <class ‘__main__.Human‘>,
 <class ‘object‘>]
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

原文地址:https://www.cnblogs.com/hszstudypy/p/10925507.html

时间: 2024-11-05 20:33:12

Python 基础之面向对象类的继承与多态的相关文章

Python基础13 面向对象--类

Python与C++.Java等众多语言一样,被视为一种面向对象的语言. 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程. 一.类定义 一个简单的类定义如下: class Person: def set_name(self, name): self.name = name def get_name(self): return self.name def greet

Day6 - Python基础6 面向对象编程

Python之路,Day6 - 面向对象学习 本节内容: 面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法. 引子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战>的游戏,你就思考呀,人狗作战,那至少需要2个角色,一个是人, 一个是狗,且人和狗都有不同的技能,比如人拿棍打狗, 狗可以咬人,怎么描述这种不同的角色和他们的功能呢? 你搜罗了自己掌握的所有技能,写出了下面的代码来描述这两个角色 1 2 3 4 5 6 7 8 9 10 11

Python基础09 面向对象的进一步拓展

Python基础09 面向对象的进一步拓展 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 我们熟悉了对象和类的基本概念.我们将进一步拓展,以便能实际运用对象和类. 调用类的其它信息 上一讲中提到,在定义方法时,必须有self这一参数.这个参数表示某个对象.对象拥有类的所有性质,那么我们可以通过self,调用类属性. class Human(object): laugh = 'hahahaha' def show_laugh(

萌新向Python数据分析及数据挖掘 第一章 Python基础 第九节 类

第一章 Python基础 第九节 类 面向对象编程时,都会遇到一个概念,类,python也有这个概念,下面我们通过代码来深入了解下. 其实类 和函数都是为了节省代码,有了类的的概念,就可以把相同的代码写在父类,子类继承后就可以直接使用,而且通过选择对应的父类就可以直接使用对应父类的内容. 创建和使用类 1 class Dog(): #认识狗这类东西 2 def __init__(self, name, age): #狗是肯定有名字和年龄的,是个狗就有,要用户填写 3 self.name = na

python类的继承和多态

python类的继承和多态 现在属于是老年人的脑子,东西写着写着就忘了,东西记着记着就不知道了.之前学C++的时候就把类.对象这块弄得乱七八糟,现在是因为很想玩python,所以就看看python的类和对象. 就像说的,类有三个特征:封装.继承.多态. 1.封装:类封装了一些方法,可通过一定的规则约定方法进行访问权限. C++中的成员变量有public.private.ptotected. 在python中,默认的成员变量都是public的,如果成员变量前面是加两个下划线,表示该成员变量是私有的

python之7-2类的继承与多态

类的继承的意思就如同父子关系一样,这个儿子继承了父亲的一切,但是在某些地方(属性)相同的时候,儿子的属性大于老子的属性(覆盖),最底层类,总会继承最接近它的那个类的属性init 类的多态总是和继承相连的,没有继承,就没有多态一说.一个子类的实例,它即属于这个子类,也属于父类,比如:父亲A和儿子B,儿子B即属于儿子类,也属于人类,但是它不属于父亲类 多态是面向对象语言的一个基本特性,多态意味着变量并不知道引用的对象是什么,根据引用对象的不同表现不同的行为方式.在处理多态对象时,只需要关注它的接口即

【游戏开发】在Lua中实现面向对象特性——模拟类、继承、多态

一.简介 Lua是一门非常强大.非常灵活的脚本语言,自它从发明以来,无数的游戏使用了Lua作为开发语言.但是作为一款脚本语言,Lua也有着自己的不足,那就是它本身并没有提供面向对象的特性,而游戏开发是一项庞大复杂的工程,如果没有面向对象功能势必会为开发带来一定的不便.不过幸好Lua中有table这样强大的数据结构,利用它再结合元表(metatable),我们便可以很方便地在Lua中模拟出类.继承和多态等面向对象编程具有的特性. 二.前提知识 按照惯例,我们还是先来熟悉一下必要的前提知识,以便方便

综合运用类、继承、多态,完成一个公司人员管理类层次结构(未完待续)

1.Target /*综合运用类.继承.多态等技术,完成一个公司人员管理类层次结构,用来描述人员信息等, 重载各种运算符,完成数据库内容的赋值.添加.工资增长等.*/ 2.Code #include <iostream> #include <cstring> #include <string> #include <cstdio> #include<cstdlib> #define TECH const string name, const int

实验6:类的继承和多态

南京信息工程大学实验报告 实验名称 类的继承和多态 实验日期 2018-5-29 得分 指导教师 耿学华 系 计软院 专业 计嵌+软嵌 年级 2017 级 班次 (1) 姓名 施昊阳 学号 20161334026 一.实验目的 理解类的继承和派生机制 掌握派生类的定义和使用 掌握派生类成员的标识与访问中同名覆盖原则.二元作用域分辨符和虚基类的用法 掌握派生类构造函数和析构函数的定义及调用次序 理解运算符重载的目的,掌握运算符重载函数的编写方法 二.实验准备 类的继承和派生 请结合第 7 章课件和