文档章节

python面向对象中的封装、继承、多态

o
 osc_g8254g7s
发布于 2019/08/19 20:41
字数 1284
阅读 33
收藏 0

精选30+云产品,助力企业轻松上云!>>>

封装

可以简单的理解为隐藏一切可以隐藏的实现细节,只向外界提供简单的编程接口。我们在类中定义的方法其实就是把数据和数据的操作封装起来了,在我们创建了对象之后,只需要给对象发送一个消息(调用方法)就可以执行方法中的代码,也就是说我们只需要知道方法的名字和传入的参数(方法的外部视图),而不需要知道方法内部的实现细节(方法的内部视图)。

练习:定义一个类实现一个数字数种

import time


class Clock:

    def __init__(self):
        # 获取当前系统时间
        t = time.localtime()
        self._hour = t.tm_hour
        self._minute = t.tm_min
        self._second = t.tm_sec

    def run(self):
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        return "%02d:%02d:%02d" % (self._hour, self._minute, self._second)


def main():
    clock = Clock()
    while True:
        # 将光标退到当前行首
        print("\r%s" % clock.show(), end="")
        time.sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

继承

在现实生活中,继承一般指的是子女继承父辈的财产,如下图

搞不好,结果如下..

在程序中继承是描述事物之间的所属关系,例如猫和狗都属于动物,程序中便可以描述为猫和狗继承自动物;同理,波斯猫和巴厘猫都继承自猫,而沙皮狗和斑点狗都继承自狗,如下如所示:

子类可以继承父类的公共属性和公共方法,父类中私有的属性和方法不能被继承。

单继承

一般只继承一个父类就叫做单继承,在java等静态语言中只能继承一个父类,也就不存在单继承和多继承了。 示例代码:

# 定义一个父类,如下:
class Cat(object):

    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color

    def run(self):
        print("%s--在跑"%self.name)


# 定义一个子类,继承Cat类如下:
class Bosi(Cat):
	# 子类没有实现__init__方法,则自动调用父类的__init__方法

    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)


bs = Bosi("印度猫")
print('bs的名字为:%s'%bs.name)
print('bs的颜色为:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()

"""
输出结果:
bs的名字为:印度猫
bs的颜色为:白色
印度猫--在吃
波斯--在跑
"""

多继承

从图中能够看出,所谓多继承,即子类有多个父类,并且具有它们的特征。 多继承的格式如下:

# 定义一个父类
class A:
    def printA(self):
        print('----A----')

# 定义一个父类
class B:
    def printB(self):
        print('----B----')

# 定义一个子类,继承自A、B
class C(A,B):
    def printC(self):
        print('----C----')

obj_C = C()
obj_C.printA()
obj_C.printB()

"""
输出结果:
----A----
----B----
"""

如果在上面的多继承例子中,如果父类A和父类B中,有一个同名的方法,那么通过子类去调用的时候,调用哪个?

class A:
    def print(self):
        print('----A----')


class B:
    def print(self):
        print('----B----')

# 定义一个子类,继承自A、B
class C(A,B):
    pass

obj_C = C()
obj_C.print()

"""
输出结果:
----A----
"""

事实上调用的顺序取决于C类先继承的是哪个类,先继承的类会先被调用。 也可通过__mor__查看C类的对象搜索方法时的先后顺序,接上面的代码

print(C.__mro__)
"""
输出结果:
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
"""

重写父类的方法

所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法

class Cat:
    def sayHello(self):
        print("halou-----1")

class Bosi(Cat):

    def sayHello(self):
        print("halou-----2")
        
class Bali(Cat):

    def sayHello(self):
        print("halou-----3")

bosi = Bosi()
bali= Bali()
bosi.sayHello()
bali.sayHello()
"""
输出结果:
halou-----2
halou-----3
"""

通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本,当我们调用这个经过子类重写的方法时,不同的子类对象会表现出不同的行为,这个就是多态(poly-morphism)

调用父类的方法

class Cat:
    def __init__(self,name):
        self.name = name
        

class Bosi(Cat):

    def __init__(self,name):
        # 调用父类的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 调用父类的__init__方法2
        #super(Bosi,self).__init__(name)
        # 调用父类的__init__方法3
        super().__init__(name)
        self.color = 'yellow'

    def getName(self):
        return self.name

bosi = Bosi('xiaohua')

print(bosi.name)
print(bosi.color)
"""
输出结果:
xiaohua
yellow
"""

总结:

  • 上文说过如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法,子类不重写 __init __,实例化子类时,会自动调用父类定义的 __init __。
  • 如果子类重写了__init__ 时,实例化子类,就不会调用父类已经定义的 __init __。
  • 如果重写了__init __ 时,要继承父类的构造方法,可以使用如下方法:
    • super(子类,self).init(参数1,参数2,....)
    • 父类名称.init(self,参数1,参数2,...)

多态

多态的概念是应用于Java和C#这一类强类型语言中,而Python崇尚“鸭子类型”。

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
Python面向对象这样理解更简单

Python虽然是解释型语言,但从设计之初就已经是一门面向对象的语言,对于Python来说一切皆为对象。正因为如此,在Python中创建一个类和对象是很容易的,当然如果习惯面向过程或者函数的写法也...

老男孩python
2019/01/28
0
0
Python面向对象你不知道的特点

Python虽然是解释型语言,但从设计之初就已经是一门面向对象的语言,对于Python来说一切皆为对象。正因为如此,在Python中创建一个类和对象是很容易的,当然如果习惯面向过程或者函数的写法也...

lmseo5hy
03/31
0
0
Python是面向对象的语言吗?python编程

  Python虽然是解释型语言,但从设计之初就已经是一门面向对象的语言,对于Python来说一切皆为对象。正因为如此,在Python中创建一个类和对象是很容易的,当然如果习惯面向过程或者函数的写...

老男孩Linux培训
2018/06/08
8
0
python面向对象三大特征

面向对象的三大特性是指:封装、继承和多态。 Python3 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Pyt...

osc_h51vfdqy
2019/05/04
1
0
Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1、面向对象的三大特性: (1)继承 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类...

osc_lbaj0fqn
2019/09/25
3
0

没有更多内容

加载失败,请刷新页面

加载更多

MongoDB入门系列——3.可视化工具篇

点击上方,轻松关注!! 前面我们已经介绍了MongoDB怎么安装,接下来要安装他的可视化工具——Studio 3T。 先到这下载一个压缩包,百度网盘,https://pan.baidu.com/s/1M8mlWo334KE8I1_UA2Da...

学习Java的小姐姐
2018/11/08
17
0
分层图的绘制 python(来自国外课程)

Exercise 10: Hierarchical clustering of the grain data In the video, you learnt that the SciPy linkage() function performs hierarchical clustering on an array of samples. Use th......

齐勇cn
48分钟前
13
0
微信小程序超简单的双向绑定(类似vue的v-model)

<input model:value="{{value}}" />

祖达
48分钟前
9
0
为什么AngularJS在select中包含一个空选项? - Why does AngularJS include an empty option in select?

问题: I've been working with AngularJS for the last few weeks, and the one thing which is really bothering me is that even after trying all permutations or the configuration de......

技术盛宴
51分钟前
13
0
centos宝塔面板安装及常见错误处理(超级详细)

原文连接:https://www.wjcms.net/archives/centos%E5%AE%9D%E5%A1%94%E9%9D%A2%E6%9D%BF%E5%AE%89%E8%A3%85%E5%8F%8A%E5%B8%B8%E8%A7%81%E9%94%99%E8%AF%AF%E5%A4%84%E7%90%86%E8%B6%85%E7%......

神兵小将
今天
17
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部