封装

关注公众号“轻松学编程”了解更多。

1、概念

面向对象语言的三大特征:封装, 继承, 多态。

广义的封装: 类和函数的定义本身就是封装的体现。

狭义的封装:一个类的某些属性,不希望外界直接访问,而是把这个属性私有化[只有当前类持有],然后暴露给外界一个访问的方法。

封装的本质:就是属性私有化的过程。

封装的好处:提供了数据的复用性,保证了数据的安全性。

举例:插排

2、使用

class Person(object):

    def __init__(self, name, age, height, weight, money):
self.name = name
self.__age__ = age
self.weight = weight
self.__money = money
self.__height = height def run(self):
print(self.__money) def eat(self):
print("eat")
# 通过内部方法,去修改、获取私有属性
# 通过自定义的方法实现对私有属性的赋值与取值
# set方法:setxxx
def setMoney(self, money):
# 数据的过滤
if money < 0:
money = 0
self.__money = money # get方法:getXXX
def getMoney(self):
return self.__money per = Person("hanmeimei", 20, 170, 55, 10000) # 1.属性被私有化之后的访问
# 如果要让内部属性不被外部直接访问,在属性前加两个下划线(__),
# 在python中如果在属性前面加两个下划线,name这个属性就变成了私有属性[private]
# 私有属性的含义:在外界不能像以前那么直接访问
# print(per.__money) #无法在外界直接访问
per.run() # 内部可以访问 # 2.解决办法: 如何对私有属性取值和赋值
# 属性被私有化之后,可以通过get/set的方法进行访问
per.setMoney(10)
print(per.getMoney()) # 3.工作原理
# 不能直接访问per.__money是因为python解释器把__money变成了_Person__money
# 仍然可以使用_Person__money去访问,但是强烈不建议这么干,不同的解释器可能存在解释的变量名不一致的问题
per._Person__money = 1
print(per.getMoney()) # 4.特殊情况
# 在Python中 __xxx__ 属于特殊变量,将不再属于私有变量,可以直接访问
print(per.__age__) # 在python中 __xxx变量,这样的实例变量外部是可以访问的,但是,按照约定的规则
# 当我们看到这样的变量时,意思虽然是"虽然我可以被访问,但是请把我视为私有变量,不要直接访问我"
print(per._Person__height)
输出:
10000
10
1
20
170

继承

1、概念

如果两个或者两个以上的类具有相同的属性和方法,我们可以抽取一个类出来,

在抽取的类中声明公共的部分

​ 被抽取出来的类 ——父类 超类 基类

​ 其他类 —— 子类 派生类

​ 他们之间的关系 ——子类继承自父类

2、单继承

简单来说,一个子类只有一个父类,被称为单继承

演示:test.py 文件

注意:在使用继承时,尽量一个类存在于一个模块中

from person import Person
from student import Student
from worker import Worker per = Person("aa", 1, 2)
stu = Student("tom", 18, 12345, 110)
print(stu.name, stu.age)
stu.run() print(stu.stuId)
#私有属性
#print(stu.__money)
print(stu.getMoney())#通过继承过来的共有方法访问私有属性
#stu.stuFunc() wor = Worker("lilei", 20, 111)
print(wor.name, wor.age)
wor.eat("apple") #子类对象调用父类同名的函数,则优先调用子类中的函数
#本质是子类中的方法覆盖了父类中同名的函数
wor.run() print(per.getMoney()) #父类对象不能访问子类特有的属性或方法
#print(per.stuId)
输出:
tom 18
run
110
12345
lilei 20
eat apple
子类中的run方法被调用了
2

person.py文件:

#以前的写法 class Person(object):
#但是实质上,如果没有显示的写出父类,则这个类的父类默认为object
#object是所有类的父类或者超类
class Person(object):
#构造方法
def __init__(self, name, age, money):
self.name = name
self.age = age
self.__money = money #get/set方法
def setMoney(self, money):
self.__money = money def getMoney(self):
return self.__money def run(self):
print("run") def eat(self, food):
print("eat", food)
#student.py文件
from person import Person
class Student(Person):
def __init__(self, name, age, money, stuId):
#调用父类中的构造方法
#方法1 super(当前类,self).__init__(参数列表)
#super(Student,self).__init__(name, age, money, stuId)
#方法2 父类名.__init__(属性列表)
Person.__init__(self, name, age, money)
#子类可以有一些自己独有的属性
self.stuId = stuId
def setFunc(self):
print(self.__money)
#worker.py文件
from person import Person class Worker(Person):
def __init__(self, name, age, money):
super(Worker,self).__init__(name, age, money)
# 在子类中定义和一个父类中重名的函数
def run(self):
print("子类中的run方法被调用了")

总结:

继承的特点:

a. 子类对象可以直接访问父类中未私有的对象

b. 子类对象可以调用父类中的方法

c. 父类对象不能访问子类中特有的属性或者方法

优缺点:

优点:

1.可以简化代码,减少冗余

2.提高代码的维护性

3.提高了代码的安全性

缺点:

耦合和内聚被用来描述类与类之间的关系,耦合性越低,内聚性越高,说明代码越好。

但是,在继承关系中,耦合性相对比较高,如果修改父类,子类也会随着变化。

3、多继承

顾名思义:就是一个子类中可以有多个父类,比如一个孩子有一个爸爸一个妈妈

from  child import Child

def main():
c = Child(300, 100,"xiaoming")
print(c.money, c.faceValue)
c.play()
c.eat()
#注意:如果多个父类中的方法名相同,默认调用的是子类括号中排前面的父类中的方法
#此时调用的是Father中func方法
if __name__ == "__main__":
main()
输出:
300 100
play
eat
#father.py文件
class Father(object):
def __init__(self, money):
self.money = money
def play(self):
print("play")
def func(self):
print("Father")
#mother.py文件
class Mother(object):
def __init__(self, faceValue):
self.faceValue = faceValue def eat(self):
print("eat") def func(self):
print("Mother")
#child.py文件
from father import Father
from mother import Mother class Child(Father, Mother):
def __init__(self, money, faceValue,name):
#注意:分别调用各个父类中的构造方法
Father.__init__(self, money)
Mother.__init__(self, faceValue)
#子类中同样可以有自己独有的特性
self.name = name

总结:

  1. 子类可以从多个父类中继承属性和方法
  2. 一个父类可以有多个子类
  3. 一个子类可以有多个父类

4、函数重写

4.1、系统函数
'''
重写:将函数重写一遍
__str__():在调用print打印对象时自动调用,是给用户用的,是一个描述对象的方法.
__repr__():是给机器用的,在python解释器里面直接敲对象名在回车后调用方法
注意:在没有str,且有repr时,str=repr
'''
class Animal(object):
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
def __str__(self):
return "%s-%d-%d-%d"%(self.name, self.age, self.height, self.weight)
ani = Animal("大黄", 5, 60, 25)
#print(per.name, per.age, per.height, per.weight)
#在打印ani时自动调用str函数
print(ani) #优点或者使用时机:当一个对象的属性值很多,并且都需要打印,重写__str__方法后,简化了代码,方便查看.
输出:
大黄-5-60-25

5、自定义函数

重写函数的时机:当父类中函数的功能满足不了子类的需求时,就可以进行重写。

演示:

from smallAnimal import SmallAnimal
from cat import Cat
c = Cat()
c.func()
#smallAnimal.py文件
class SmallAnimal(object):
def func(self):
print("wwww")
#cat.py文件
from smallAniml import SmallAnimal
class Cat(SmallAnimal):
def func(self):
print("呵呵呵")

后记

【后记】为了让大家能够轻松学编程,我创建了一个公众号【轻松学编程】,里面有让你快速学会编程的文章,当然也有一些干货提高你的编程水平,也有一些编程项目适合做一些课程设计等课题。

也可加我微信【1257309054】,拉你进群,大家一起交流学习。
如果文章对您有帮助,请我喝杯咖啡吧!

公众号

关注我,我们一起成长~~

python类的封装与继承的更多相关文章

  1. 孤荷凌寒自学python第二十三天python类的封装

    孤荷凌寒自学python第二十三天python类的封装 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 一.从怎么样访问类的内部代码块中定义的私有属性说起 类中定义的私有属性和私有方法是无法被 ...

  2. ECMAScript6 中 类的封装与继承

    ECMASCRIPT6中实现了class关键字,这样使我们更容易也更形象的进行类的操作 <script type="text/javascript"> class OF ...

  3. python面向对象(封装、继承、多态)+ 面向对象小栗子

    大家好,下面我说一下我对面向对象的理解,不会讲的很详细,因为有很多人的博客都把他写的很详细了,所以,我尽可能简单的通过一些代码让初学者可以理解面向对象及他的三个要素. 摘要:1.首先介绍一下面向对象 ...

  4. python面向对象编程 -- 封装、继承

    面向对象编程 -- 封装.继承 面向对象编程三要素:封装.继承和多态.本文主要看和封装.继承相关的概念:在python中多态的概念比较模糊,本文不做讨论. 1 封装 封装:将数据和操作组装到一起,对外 ...

  5. Python中的封装,继承和多态

    面向对象的三大特性:封装,继承和多态 封装:在类的内部定义属性和方法,通过对象或类名来访问属性和方法,隐藏功能的实现细节,也可以设置访问权限. 广义的封装:实例化一个对象,给对象空间封装一些属性:狭义 ...

  6. python 类的成员及继承

    1. @staticmethod 静态方法 静态方法不能访问实例变量和类变量,除了身处类里面,所以只能通过类调用以外,它其实和类没有什么关系.如果想要用它访问实例变量或类变量,需要把实例和类传递给函数 ...

  7. Java—类的封装、继承与多态

    一.类和对象 1.类 类是数据以及对数据的一组操作的封装体. 类声明的格式: 类声明 { 成员变量的声明: 成员方法的声明及实现: } 1.1 声明类 [修饰符] class 类<泛型> ...

  8. java中关于类的封装与继承,this、super关键字的使用

    原创作品,可以转载,但是请标注出处地址http://www.cnblogs.com/V1haoge/p/5454849.html. this关键字: this代表当前对象,它有以下几种用途: 1.本类 ...

  9. php函数、类和对象以及类的封装、继承、类的静态方法、静态属性

    1.函数     php内置函数可以直接使用,如果没有安装php扩展即可     自定义函数 //函数function 函数名 function dump($var = null){ //支出默认参数 ...

随机推荐

  1. Python练习题 011:成绩打分

    [Python练习题 011] 利用条件运算符的嵌套来完成此题:学习成绩>=90分的同学用A表示,60-89分之间的用B表示,60分以下的用C表示. ---------------------- ...

  2. plt.imshow()显示图片色差问题

    转载:https://www.cnblogs.com/darkknightzh/p/6039667.html 由于系统缺少某些库,导致cv2.imshow()无法使用,于是使用matplotlib.p ...

  3. Matlab绘制子图subplot使用攻略

    参考:https://jingyan.baidu.com/article/915fc414ad794b51394b20e1.html Matlab绘制子图subplot使用攻略 听语音 原创 | 浏览 ...

  4. P2832 行路难

    题面 Link 题目背景 小X来到了山区,领略山林之乐.在他乐以忘忧之时,他突然发现,开学迫在眉睫 题目描述 山区有 \(n\) 座山.山之间有 \(m\) 条羊肠小道,每条连接两座山,只能单向通过, ...

  5. 不会吧,这也行?iOS后台锁屏监听摇一摇

    目录 背景介绍 探索过程 其他 APP 有没有类似功能 系统提供的摇一摇回调能否满足 其他方法能否实现 利用 CoreMotion 框架,监听加速计原始数据 通过加速计监听摇一摇 控制器相关逻辑和代码 ...

  6. 安装memcache,步骤

    1.先下载emcache.rar安装包<ps:随便安装在哪里文件夹,或者新建文件夹都是可以的> 2.解压安装包<ps:运行里面的程序> 3.然后根据自己的phpstudy的版本 ...

  7. day53 Pyhton 前端04

    内容回顾: 盒子: 内边距:padding,解决内部矛盾,内边距的增加整个盒子也会增加 外边距:margin,解决外部矛盾,当来盒子都有外边距的时候,取两者最大值 边框:border border-c ...

  8. xuexi0.1

    1.C语言通过编译器对内存进行了一定的封装.a +=4等效于a=a+4.C语言中数据类型的本质含义:表示一个内存格子的长度和解析方法.(int *)0:表示0是一个指针,这个指针指向一个int类型的数 ...

  9. firstBlog

    第一篇博客 markdown语法的学习 基本语法 标题与段落 在文字前面加1-6个#号来表示来代表一级标题到六级标题 一级标题 五级标题 列表 对于无序列表,可以使用字符-,+和*作为列表的标记 - ...

  10. spring boot:用redis+redisson实现分布式锁(redisson3.11.1/spring boot 2.2)

    一,为什么要使用分布式锁? 如果在并发时锁定代码的执行,java中用synchronized锁保证了线程的原子性和可见性 但java锁只在单机上有效,如果是多台服务器上的并发访问,则需要使用分布式锁, ...