python之类的封装，继承，多态
目录
一，封装
1，类和对象
①创建类，语法
②实例化对象
③调用类属性和方法语法
2，self
3，属性
①类属性
②添加对象属性
③获取对象属性
④私有属性和私有方法
a，设置私有属性和方法
b，获取和修改私有属性的值
4，方法
①类方法
②静态方法
5，魔法方法
①__XX__()函数叫做魔法方法，指的是具有特殊功能的函数
②__init__()
③__str__() --------- 类似Java语言中的toString()方法
二，继承
1，单继承
2，多继承
3，查看一个类的继承关系
4，子类重写父类的同名属性和方法
5，子类调用父类的同名属性和方法
三，多态
1，概念
2，步骤
四，完整代码如下
一，封装
1，类和对象
Java和python都是面向对象的语言
①创建类，语法
class 类名:
代码
#Java class Person{ }#python 首字母需要大写
class Student:pass②实例化对象
对象名 = 类名( )
# 实例化 #java new Student() # python s=Student() #打印s 肯定是内存地址 print(s)控制台输出<__main__.Student object at 0x000001C64DC733D0>
③调用类属性和方法语法
对象名.属性；
对象名.方法()
class Student:def say(self):# self这个参数是当前这个对象，不需要自己传参# 可以通过self去取得自身携带的一些东西，如属性print("hello",self)# 实例化 s=Student() print(s) s.say()控制台输出，self和对象 内存地址一致
<__main__.Student object at 0x0000029B91939370>
hello <__main__.Student object at 0x0000029B91939370>
一个函数定义在类里面叫方法
2，self
self指的是调用该函数的对象
函数中默认参数self，该默认的参数self指的是调用该函数的对象
案例1：self和对象的内存地址是否一致？
class Student:def say(self):# self这个参数是当前这个对象，不需要自己传参# 可以通过self去取得自身携带的一些东西，如属性print("hello",self)# 实例化 s=Student() print(s) s.say()控制台输出，self和对象 内存地址一致
<__main__.Student object at 0x0000029B91939370>
hello <__main__.Student object at 0x0000029B91939370>
案例2：如果是多个对象，调用同一个函数，self地址是否一致？
3，属性
①类属性
a，可以通过类名或者对象访问，写在类里面
语法： 变量名 = 变量值
class Student:name='小宝'sex:strage=20def say(self):# self这个参数是当前这个对象，不需要自己传参# 可以通过self去取得自身携带的一些东西，如属性print("hello",self)b，修改类属性
类属性的修改，只能通过类修改，不能通过对象修改
语法：类名.变量名=变量值
# name 实例属性 s.name="张三"#添加了一个实例属性name 值是张三 Student.name="haha"#修改了类属性 # s有几个name属性？ 【name类属性】【name实例属性】 del s.name #删除了name实例属性 # s.birth='2021-1-1'#不会报错，python是弱类型，对变量没有类型限制，对对象没有属性限制
注意：如果通过对象对属性进行重新赋值，实际上是给该对象又重新定义了一个属性名一样的变量
②添加对象属性
a，类外面添加对象属性
语法： 对象名.属性名 = 值 （注意：该种方式添加的属性，只能属于该对象的）
s.name="小张"
b，类里面添加对象属性
语法： 变量名 = 变量值 （注意：该种方式添加的属性，属于所有类对象的）
name='小宝'
c，__init__()方法中添加对象属性
语法：self.属性名 = 值 （用在__init__()初始化方法中）
def __init__(self,name:str="",age:int=0):#这里的str与int只是需要的类型，给其他类型也不会报错self.__name=nameself.__age=age
③获取对象属性
a，类外面获取对象属性，语法：对象名.属性名
print(s.name)
b，类里面获取对象属性，语法：self.属性名 （用在函数中）
def __str__(self):
return f"名字{self.__name},年龄{self.__age}"
④私有属性和私有方法
a，设置私有属性和方法
在属性名和方法名前面加两个下划线__
定义为私有属性和私有方法，不能被子类继承
# 1.私有化属性 __name:str __age:int
b，获取和修改私有属性的值
获取，定义getXXX()
修改，定义setXX()
#2,提供get/set def get_name(self):return self.__name def set_name(self,name:str):return self.__name
4，方法
①类方法
用装饰器@classmethod标识
@classmethod def test(cls):cls.__name='xxx'
②静态方法
用装饰器@staticmethod标识
@staticmethod
def say():print("hello")5，魔法方法
①__XX__()函数叫做魔法方法，指的是具有特殊功能的函数
def __str__(self):return f"名字{self.__name},年龄{self.__age}"②__init__()
a，__init__()：初始化对象
在创建一个对象时默认被调用，不需要手动调用
# 构造函数
def __int__(self):
pass
b，带参数的__init__()方法
# 构造函数 def __init__(self,name:str="",age:int=0):#这里的str与int只是需要的类型，给其他类型也不会报错self.__name=nameself.__age=age
③__str__() --------- 类似Java语言中的toString()方法
a，print输出对象时，默认打印的是对象在内存中的地址
b，如果类中定义__str__方法，则会打印__str__方法中的内容
class Student:# 1.私有化属性__name:str__age:intdef __str__(self):return f"名字{self.__name},年龄{self.__age}"二，继承
1，单继承
父类，class 父类(object):
class Parent(object):name='张三 'def cook(self):print("正在煮饭[辣椒炒肉]")子类，class 子类(父类):
class Mother(object):def cook(self):print("正在煮饭[红烧肉]")2，多继承
子类，class 子类(父类1，父类2)
class Parent(object):name='张三 'def cook(self):print("正在煮饭[辣椒炒肉]")class Mother(object):def cook(self):print("正在煮饭[红烧肉]")class Son(Mother,Parent):def cook_test(self):super(Son,self).cook()print("正在煮饭[茄子豆角]")注意，如果一个类继承多个父类，优先继承父类1的同名属性和方法
3，查看一个类的继承关系
类.__mro__
① print(Parent.mro())② print(Son.__mro__)
4，子类重写父类的同名属性和方法
class Cs():def cook(self):passclass Parent(Cs):def cook(self):print("正在煮饭[辣椒炒肉]")class Mother(Cs):def cook(self):print("正在煮饭[红烧肉]")Parent，Mother重写了Cs的重名属性和方法
注意，如果子类重写了父类的同名属性和方法，则会调用子类中的同名属性和方法
5，子类调用父类的同名属性和方法
在子类的同名方法中调用，语法：父类类名.方法(self)
super()，调用父类方法，super().方法()
（适用于 单继承）
三，多态
1，概念
多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行效果
2，步骤
a，定义父类，提供父类方法
b，定义子类，重写父类方法
c，传递子类对象给调用者，返回不同的结果
四，完整代码如下
# 面向对象的语言#定义类
# Java class Person{ }
# python 首字母需要大写
class Student:name='小宝'sex:strage=20def say(self):# self这个参数是当前这个对象，不需要自己传参# 可以通过self去取得自身携带的一些东西，如属性print("hello",self)# 实例化
# java new Student()
# python
s=Student()
s2=Student()
#打印s 肯定是内存地址
# print(s)
# s.say()
# name 实例属性
s.name="张三"#添加了一个实例属性name 值是张三
Student.name="haha"#修改了类属性
# s有几个name属性？ 【name类属性】【name实例属性】
del s.name #删除了name实例属性
# s.birth='2021-1-1'#不会报错，python是弱类型，对变量没有类型限制，对对象没有属性限制
print(s.name)
print(s2.name)
class Student:# 1.私有化属性__name:str__age:int# 构造函数# def __int__(self):# pass# 构造函数def __init__(self,name:str="",age:int=0):#这里的str与int只是需要的类型，给其他类型也不会报错self.__name=nameself.__age=age#2,提供get/setdef get_name(self):return self.__namedef set_name(self,name:str):return self.__namedef __str__(self):return f"名字{self.__name},年龄{self.__age}"# def __set_name__(self, owner, name):@staticmethoddef say():print("hello")@classmethoddef test(cls):cls.__name='xxx'Student.test()
s1=Student("小宝",20)
s2=Student()
s3=Student(name="小黑")
s4=Student(age=21)
# print(s.get_name())
print(s1)
print(s2)
print(s3)
print(s4)
Student.say()
import random
# java类都直接或者间接继承object
# python类都直接或者间接继承object
# 如果属性或方法已经冲突，拿前面的
class Parent(object):name='张三 'def cook(self):print("正在煮饭[辣椒炒肉]")class Mother(object):def cook(self):print("正在煮饭[红烧肉]")# class Son(Mother,Parent):
# pass
# class Son(Parent,Mother):
# pass
class Son(Mother,Parent):def cook_test(self):super(Son,self).cook()print("正在煮饭[茄子豆角]")# s=Son()
# # print(Parent.mro())
# # print(Son.mro())
# s.cook()
# s.cook_test()
# print(Son.mro())
# print(Son.__mro__)
#
# random.randint()
class Cs():def cook(self):passclass Parent(Cs):def cook(self):print("正在煮饭[辣椒炒肉]")class Mother(Cs):def cook(self):print("正在煮饭[红烧肉]")class Son(Mother,Parent):def cook_test(self):super(Son,self).cook()print("正在煮饭[茄子豆角]")# # 需要一个厨师
# def mai_fan(chushi:Cs):
# # 断言----会抛出异常
# assert isinstance(chushi,Cs)
# chushi.cook()# 需要一个厨师
def mai_fan(chushi:Cs):# 断言----会抛出异常if isinstance(chushi,Cs) == True:chushi.cook()else:print("你当前不是厨师")c1=Parent()
c2=Mother()
c3=Son()
mai_fan(c1)
mai_fan(c2)
mai_fan(c3)
python之类的封装，继承，多态相关推荐
- python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态
六.Python面向对象--类与对象\封装\继承\多态 1.什么是面向对象编程 1.1 程序设计的范式:程序可控,易于理解 1.2 抽象并建立对象模型 1.3 程序是不同对象相互调用的逻辑.每个对象在 ...
- python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态 面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴 封装 什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装 封装就是指将数据或者函 ...
- c语言编程 菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
- 面向对象 编程及面向对象三大属性：封装 继承 多态
面向对象 面向对象(Object Oriented,OO)是软件开发方法.面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统.交互式界面.应用结构.应用平台.分布式系统.网络管理结构. ...
- Java继承_Hachi君浅聊Java三大特性之 封装 继承 多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
- python--编写程序：实现乐手弹奏乐器，乐手可以弹奏不同的乐器而发出不同的声音------使用类的封装继承多态的问题/使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
编写程序:实现乐手弹奏乐器,乐手可以弹奏不同的乐器而发出不同的声音 ------使用类的封装继承多态的问题 class Instrumnet():#乐器类def make_sound(self):pa ...
- 大数据笔记8—java基础篇4（面向对象-封装-继承-多态）
面向对象 一.面向对象 1.面向过程 1.2.举例 1.3.总结 二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例 三.类的使 ...
- 小白理解——封装继承多态
一.封装 是什么:首先是抽象,把事物抽象成一个类,其次才是封装.对外表示为一个对象,隐藏对象的属性和动作实现的细节,仅对外公开接口. ...
- Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态
Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
- 白话文带你了解 封装 继承 多态
这里讲的仅仅是带你理解 封装 继承 多态 染好您可以移步去别的文章学习具体的实现 (只是个人理解 您可以不爱,请别伤害哦!) 首先你要知道 java是面向对象的,说白了就是我拿你当个人,请认清你的地位 ...
最新文章
- 仿QQ空间用一个tableview显示多种自定义cell
- Oracle中的 IN, NOT IN和 EXISTS, NOT EXISTS的區別
- AndroidStudio3.0无法打开Android Device Monitor的解决办法(An error has occurred on Android Device Monitor)...
- 禁用引导模态区域之外的单击以关闭模态
- Kubernetes — Flannel CNI
- LiveGBS国标流媒体-摄像机网页低延时无插件直播实现
- arduino与matlab联调出现问题
- 安卓应用安全指南 翻译完成
- web测试与app测试异同
- 由于找不到appvisvsubsystems32.dll_终于熬到孩子上幼儿园，宝妈却找不到工作了，背后原因让人心酸...
- 软考初级程序员---题目（七）
- 史上最全英文免费编程电子书列表
- EXE文件反编译工具下载
- 仿真小白必须知道的！有限元法-它是什么？FEM和FEA解释
- word文字间距设置教程
- 单片机什么叫位寻址？/不可位寻址？
- 一名失败人士对大学教育的一些看法
- 训练误差与泛化误差的说明
- 一个cc1101功耗的问题
- 基于SpringBoot大学生心理健康咨询管理系统的分析与设计