目录
1.初识对象
2. 类的成员方法
3. 类和对象
4. 构造方法
5. 其它内置方法
6. 封装
7. 继承
7.1 继承的基础语法
7.2 复写和调用父类成员
8. 多态
1.初识对象
1. 生活中或是程序中,我们都可以使用设计表格、生产表格、填写表格的形式组织数据。
2. 进行对比,在程序中:
设计表格,称之为:设计类(class)
打印表格,称之为:创建对象
填写表格,称之为:对象属性赋值
# 设计类
class Student:
name = None
age = None
sex = None
# 创建对象
stu_1 = Student()
# 对象属性赋值
stu_1.name = "张三"
stu_1.age = 18
stu_1.sex = "男"
# 张三
print(stu_1.name)
# 18
print(stu_1.age)
# 男
print(stu_1.sex)
2. 类的成员方法
1.类是由哪两部分组成?
- 类的属性:成员变量。
- 类的行为:成员方法。
注意:函数是定义在类外的,而方法是定义类内的。
2.类和成员方法的定义语法
3.self的作用
- self表示类对象本身的作用。
- 只有通过self,成员方法才能访问类的成员变量。
- self虽然出现在形参列表中,但是不占用参数位置。
class Student:
name = None
def say_hi(self):
print(f"大家好,我是{self.name},请多多指教!")
def say_hi2(self,msg):
print(f"大家好,我是{self.name},{msg}")
stu1 = Student()
stu1.name = "张三"
stu1.say_hi()
stu2 = Student()
stu2.name = "李四"
stu2.say_hi2("请多多关照!")
3. 类和对象
1. 现实世界的事物由什么组成?
- 属性
- 行为
类也可以包含属性和行为,所以使用类描述现实世界事物是非常合适的。
2. 类和对象的关系是什么?
- 类是程序中的“设计图纸”。
- 对象是基于图纸生产的具体实体。
3. 什么是面向对象编程?
- 面向对象编程就是,使用对象进行编程。
- 即,设计类,基于类创建对象,并使用对象来完成具体的工作。
# 设计类
class Clock:
# 序列号
id = None
# 零售价
price = None
# 响铃
def ring(self):
import winsound
winsound.Beep(2000,3000)
# 创建对象
clock1 = Clock()
# 给对象属性赋值
clock1.id = "1001"
clock1.price = 19.99
# 使用对象的属性和方法
print(f"闹钟ID:{clock1.id},价格:{clock1.price}")
clock1.ring()
# 创建对象
clock2 = Clock()
# 给对象属性赋值
clock2.id = "1002"
clock2.price = 29.99
# 使用对象的属性和方法
print(f"闹钟ID:{clock2.id},价格:{clock2.price}")
clock2.ring()
4. 构造方法
1.构造方法的名称:
__init__,注意init前后的2个下划线符号。
2.构造方法的作用:
构建类对象的时候会自动运行。
构建类对象的传参会传递给构造方法,借此特性可以给成员变量赋值。
3.注意事项:
构造方法不要忘记self关键字。
在方法内使用成员变量需要使用self。
案例
# 设计类
class Student:
# # 成员变量
# name = None
# age = None
# address = None
# 构造方法
def __init__(self,name,age,address):
self.name = name
self.age = age
self.address = address
# 循环录入学生信息并打印学生信息
for i in range(3):
print(f"当前录入第{i+1}学生信息,总共需要录入2位学生信息")
name = input("请输入姓名:")
age = input("请输入年龄:")
address = input("请输入地址:")
# 创建对象
stu = Student(name,age,address)
# 打印学生信息
print(f"学生{i+1}信息录入完成,信息为:【姓名:{stu.name},年龄:{stu.age},地址:{stu.address}】")
print("-"*47)
5. 其它内置方法
方法 | 功能 |
__init__ | 构造方法,可用于创建类对象的时候设置初始化行为 |
__str__ | 用于实现类对象转字符串的行为 |
__lt__ | 用于2个类对象进行小于或大于比较 |
__le__ | 用于2个类对象进行小于等于或大于等于比较 |
__eq__ | 用于2个类对象进行相等比较 |
class Student:
# __init__构造方法
def __init__(self,name,age):
self.name = name
self.age = age
# __str__字符串方法
def __str__(self):
return f"name={self.name},age={self.age}"
# __lt__小于符号比较方法
def __lt__(self, other):
return self.age < other.age
# __le__小于等于比较方法
def __le__(self, other):
return self.age <= other.age
# __eq__比较运算符实现方法
def __eq__(self, other):
return self.age == other.age
stu1 = Student("张三",20)
stu2 = Student("李四",21)
stu3 = Student("王五",20)
'''
调用__str__字符串方法
'''
# name=张三,age=20
print(stu1)
# name=李四,age=21
print(str(stu2))
'''
__lt__小于符号比较方法
'''
# True
print(stu1 < stu2)
# False
print(stu1 > stu2)
'''
__le__小于等于比较方法
'''
# True
print(stu1 <= stu3)
# False
print(stu1 >= stu2)
'''
__eq__比较运算符实现方法
'''
# 若不实现__eq__方法,对象之间可以比较,但是比较的是对象的内存地址
# 若实现__eq__方法,就按照自己的想法来决定2个对象是否相等
# True
print(stu1 == stu3)
6. 封装
1.封装的概念?
将现实世界事物在类中描述为属性和方法,即为封装。
2.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求,这就需要定义私有成员了。
3.如何定义私有成员?
成员变量和成员方法的命名均以__作为开头即可。
4.私有成员的访问限制?
- 类中的其它成员可以访问私有成员。
- 类对象无法访问私有成员。
案例
class Phone:
# 私有成员变量(对用户隐藏)
__is_5g_enable = False # 5g状态
# 私有成员方法(对用户隐藏)
def __check_5g(self):
if self.__is_5g_enable:
print("5g开启")
else:
print("5g关闭,使用4g网络")
# 公开成员方法(对用户公开)
def call_by_5g(self):
self.__check_5g()
print("正在通话中")
phone = Phone()
phone.call_by_5g()
7. 继承
7.1 继承的基础语法
1.什么是继承?
继承就是一个类,继承另外一个类的成员变量和成员方法。
语法:
子类构建的类对象,可以:
- 使用父类的成员变量和成员方法。
- 有自己的成员变量和成员方法。
2.单继承和多继承
单继承:一个类继承另一个类。
多继承:一个类继承多个类,按照顺序从左到右依次继承。
多继承中,如果父类有同名方法和属性,先继承的优先级高于后继承。
3.pass关键字的作用
pass是占位语句,用来保证函数(方法)或类定义的完整性,表示无内容,空的意思。
'''
单继承
'''
class Phone:
# 序列号
IMEI = None
# 厂商
producer = "HW"
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
# 面部识别
face_id = True
def call_by_5g(self):
print("2022最新5g通话")
Phone2022 = Phone2022()
# 4g通话
Phone2022.call_by_4g()
# 2022最新5g通话
Phone2022.call_by_5g()
'''
多继承
'''
class NFCReader:
nfc_type = "第五代"
producer = "HM"
def read_card(self):
print("读取NFC卡")
def write_card(self):
print("写入NFC卡")
class MyPhone(Phone,NFCReader):
pass
my_phone = MyPhone()
# 4g通话
my_phone.call_by_4g()
# 读取NFC卡
my_phone.read_card()
# 多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级
# HW
print(my_phone.producer)
7.2 复写和调用父类成员
1.复写表示:
对父类的成员属性或成员方法重新定义。
2.复写语法:
在子类中重新实现同名成员方法或成员属性即可。
3.在子类中,如何调用父类成员?
注意:只可以在子类内部调用父类的同名成员,子类的实体类对象调用默认是调用子类复写的。
class Phone:
IMEI = None
producer = "ITCAST"
def call_by_5g(self):
print("父类的5g通话")
# 子类1复写父类的成员属性和成员方法
class MyPhone1(Phone):
producer = "ITHEIMA"
def call_by_5g(self):
print("子类的5g通话")
# 子类2复写父类的成员属性和成员方法,并在成员方法中调用父类成员
class MyPhone2(Phone):
producer = "ITHEIMA"
def call_by_5g(self):
# # 方式1调用父类成员
# print(f"父类的品牌是:{Phone.producer}")
# Phone.call_by_5g(self)
# 方式2调用父类成员
print(f"父类的品牌是:{super().producer}")
super().call_by_5g()
print("子类的5g通话")
'''
子类的实体类对象调用的成员默认是调用子类复写的。
'''
my_phone1 = MyPhone1()
# ITHEIMA
print(my_phone1.producer)
# 子类的5g通话
my_phone1.call_by_5g()
my_phone2 = MyPhone2()
# 父类的品牌是:ITCAST
# 父类的5g通话
# 子类的5g通话
my_phone2.call_by_5g()
8. 多态
1.什么是多态?
多态指的是,同一个行为,使用不同的对象获得不同的状态。 如,定义函数(方法),通过类型注解声明需要父类对象,实际传入子类对象进行工作,从而获得不同的工作状态。
2.什么是抽象类(接口)?
包含抽象方法的类,称之为抽象类。抽象方法是指:没有具体实现的方法(pass)称之为抽象方法。
3.抽象类的作用
多用于做顶层设计(设计标准),以便子类做具体实现。 也是对子类的一种软性约束,要求子类必须复写(实现)父类的一些方法并配合多态使用,获得不同的工作状态。
# 设计抽象类
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
# 定义函数,实现多态
def make_noise(animal: Animal):
animal.speak()
dog = Dog()
cat = Cat()
# 汪汪汪
make_noise(dog)
# 喵喵喵
make_noise(cat)