封装

类中把某些属性和方法隐藏起来,或者定义为私有,只在类的内部使用,在类的外部无法访问,或者留下少量的接口(函数)供外部访问;从上一篇文章中的私有属性与私有方法中的代码体现了该特性。

class man():
def __init__(self,name):
self.name = name
self.__passwd = "123456" def changepass(self,newpasswd):
self.__passwd = newpasswd
print(self.__passwd) liming = man("liming")
#没有liming.passwd/liming.__passwd属性
#只能通过一下changepass方法来查看或修改内部属性
liming.changepass("abc123456")

  

继承

一个种类里面,存在共有的属性和动作。比如动物类,存在共有的属性(长度、高度等)和动作(吃、跑、叫等)。在程序中是为了实现代码的重用,相同的代码不需要重复的编写。父类里定义的属性、方法自动被子类继承。

比如下面的这个例子(仅继承):

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class poodle(dog): #poodle(贵宾犬)是dog的子类.poodle类继承了dog类的所有属性与方法。
pass my_dog = poodle("小花")
my_dog.eat()
my_dog.run()
#输出
小花,正在吃...
小花,正在跑...

  

当然,子类不仅可以继承父类,还可以在父类的基础上增加其他方法和属性。

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class poodle(dog):
def lovely(self): #增加新的方法
print("%s is lovely!" % self.name) my_dog = poodle("小花")
my_dog.eat()
my_dog.run()
my_dog.lovely()
#输出
小花,正在吃...
小花,正在跑...
小花 is lovely!

  

重构父类方法(重写)

重写父类方法:

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class poodle(dog):
def run(self):
print("%s is running!" % self.name) my_dog = poodle("小花")
my_dog.eat()
my_dog.run() #输出
小花,正在吃...
小花 is running!

  

 

先执行父类方法中的代码再执行子类方法中的代码:

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class poodle(dog):
def run(self):
dog.run(self)
print("%s is running!" % self.name) my_dog = poodle("小花")
my_dog.eat()
my_dog.run() #输出
小花,正在吃...
小花,正在跑...
小花 is running!

  

完全重构构造函数:

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class poodle(dog):
def lovely(self):
print("%s is lovely!" % self.name) class jiwawa(dog):
def __init__(self,name,gun):
dog.__init__(self,name)
self.gun = gun
def wawa(self):
print("%s 是吉娃娃狗种!" % self.name)
def xgun(self):
print("%s" % self.gun) dog1 = poodle("小花")
dog1.eat()
dog1.run() dog2 = jiwawa("小黑","yes")
dog2.wawa()
dog2.xgun() ##输出
小花,正在吃...
小花,正在跑...
小黑 是吉娃娃狗种!
yes

 

也可以使用这种写法

super(jiwawa,self).__init__(name)

  

新式类与经典类

经典类是老版本,新式类是新版版。

#经典类
class dog: #新式类
class dog(object):

  

#经典类写法
dog.__init__(self,name)
#新式类写法
uper(jiwawa,self).__init__(name)

  

经典类与新式类的区别:多继承。

多继承

class dog:
def __init__(self,name):
self.name = name def eat(self):
print("%s,正在吃..."% self.name) def run(self):
print("%s,正在跑..."% self.name) class Relation(object):
def makefriends(self,obj):
print("%s要和%s交朋友!" % (self.name,obj.name)) class poodle(dog,Relation):
def lovely(self):
print("%s is lovely!" % self.name) class jiwawa(dog):
def __init__(self,name,gun):
#dog.__init__(self,name)
super(jiwawa,self).__init__(name)
self.gun = gun
def wawa(self):
print("%s 是吉娃娃狗种!" % self.name)
def xgun(self):
print("%s" % self.gun) dog2 = jiwawa("小黑","yes")
dog1 = poodle("小花") dog1.makefriends(dog2) #输出
小花要和小黑交朋友!

  

多态

  • 多态不同的子类对象调用相同的父类方法,产生不同的执行结果
  • 多态可以增加代码的灵活度,以继承和重写父类方法为前提是调用方法的技巧,不会影响到类的内部设计
  • 同一个接口多种实现
class dog:
@staticmethod
def dog_run(obj):
obj.run() class poodle(dog):
def run(self):
print("贵宾犬,正在跑!") class jiwawa(dog):
def run(self):
print("吉娃娃,正在跑") d1 = poodle()
d2 = jiwawa()
dog.dog_run(d1)
dog.dog_run(d2)

  

Python面向对象三大特性(封装、继承、多态)的更多相关文章

  1. 深入理解Java面向对象三大特性 封装 继承 多态

    1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...

  2. python 面向对象三大特性(封装 多态 继承)

    今天我们来学习一种新的编程方式:面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)注:Java和C#来说只支持面向对象编程,而python比较灵活即支持面 ...

  3. Java三大特性(封装,继承,多态)

    Java中有三大特性,分别是封装继承多态,其理念十分抽象,并且是层层深入式的. 一.封装 概念:封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别:将抽象得到的数据 ...

  4. C++三大特性 封装 继承 多态

    C++ 三大特性 封装,继承,多态 封装 定义:封装就是将抽象得到的数据和行为相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成类,其中数据和函数都是类的成员,目的在于将对 ...

  5. python面向对象三大特性之一继承、多态、封装

    继承,即在定义一个类时,以另一个类为参数,则称这个新定义的类继承了参数类,父类又称为基类. 单继承表示只继承一个类,多继承表示继承多个类. class parent1: pass class pare ...

  6. Python()- 面向对象三大特性----封装

    封装: [封装]         隐藏对象的属性和实现细节,仅对外提供公共访问方式.[好处] 1. 将变化隔离: 2. 便于使用:3. 提高复用性: 4. 提高安全性:[封装原则]      1. 将 ...

  7. python面向对象三大特性之继承

    继承是创建新类的方法,以下是几个概念 父类,基类,超类: 被继承的类 子类,派生类:继承而产出的类 单继承:继承一个父类 多继承:继承多个父类 继承: 什么是什么的关系 父类中没有的属性,在字类中出现 ...

  8. [.net 面向对象编程基础] (11) 面向对象三大特性——封装

    [.net 面向对象编程基础] (11) 面向对象三大特性——封装 我们的课题是面向对象编程,前面主要介绍了面向对象的基础知识,而从这里开始才是面向对象的核心部分,即 面向对象的三大特性:封装.继承. ...

  9. python面向对象-三大特性

    python面向对象编程三大特性 小结:前面我们说完了类和对象的关系,相信对类和对象的理解更加透彻..让我们一起去研究面向对象的三大特性吧.... 继承 1.什么继承? 在程序中继承就是事物之间的所属 ...

随机推荐

  1. Time-Frequency Networks For Audio Super-Resolution

    论文题目:2018_用于音频超分辨率的时频网络 博客作者:凌逆战 博客地址:https://www.cnblogs.com/LXP-Never/p/12345950.html 摘要 音频超分辨率(即带 ...

  2. k8s系列---网络插件flannel

    跨节点通讯,需要通过NAT,即需要做源地址转换. k8s网络通信: 1) 容器间通信:同一个pod内的多个容器间的通信,通过lo即可实现: 2) pod之间的通信,pod ip <---> ...

  3. 获取出口IP地址

    curl https://www.ipaddress.com/ |grep "My IPv4 Address" # 推荐 curl icanhazip.com curl www.t ...

  4. 杭电-------2047阿牛的eof牛肉串(C语言写)

    /* 主要看最后一个是否为O,若为O,则倒数第二个不能为O,则为a[n-2]*1*2; 若不为O,则最后一个有两个选择则为a[n-1]*2 */ #include<stdio.h> ] = ...

  5. THINKPHP-RCE-POC

    thinkphp-RCE-POC 官方公告: 1.https://blog.thinkphp.cn/869075 2.https://blog.thinkphp.cn/910675 POC: thin ...

  6. linux中权限管理命令(chmod/chown/chgrp/unmask)

    目录 chmod chown chgrp umask chmod 解释 命令名称:chmod 命令英文原意:change the permissions mode of a file 命令所在路径:/ ...

  7. opencv —— approxPolyDP 生成逼近曲线

    生成逼近曲线:approxPolyDP 函数 该函数采用 Douglas-Peucker 算法(也称迭代终点拟合算法).可以有效减少多边形曲线上点的数量,生成逼近曲线,简化后继操作. 经典的 Doug ...

  8. 刷题84. Largest Rectangle in Histogram

    一.题目说明 题目84. Largest Rectangle in Histogram,给定n个非负整数(每个柱子宽度为1)形成柱状图,求该图的最大面积.题目难度是Hard! 二.我的解答 这是一个 ...

  9. 3.Python运算符详解

    1.算数运算符 符号:+   -   *   /   %(取余.取模)   //(取整)   **(开方) 2.比较运算符 符号:>   >=   <   <=   ==(全等 ...

  10. python学习---文件修改

    1.读一行,写一行,判断字符串,修改之. f=open("yesterday2","r",encoding="utf-8") f_new=o ...