五、面向对象三大特征
面向对象三大特征是:封装、继承和多态
1. 封装
封装就是隐藏内部实现的细节,只保留功能接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68 | class WashMachine:
def __init__(self, brand, capacity):
'''
初始化
:param brand: 品牌
:param capacity: 容量
'''
self.brand = brand
self.capacity = capacity
# 是否关闭
self.hasClosed = False
# 模式 0:默认模式 1:轻揉模式 2:狂揉模式
self.__mode = 0
# 马达转速
self.motorSpeed = 0
def openDoor(self):
self.hasClosed = False
print('打开洗衣机门')
def closeDoor(self):
self.hasClosed = True
print('关闭洗衣机门')
def setMode(self,mode):
'''
调节模式
:param mode:
:return:
'''
if mode !=1 and mode !=2:
print('设置模式错误')
else:
self.__mode = mode
def __setMotorSpeed(self,speed):
'''
设置马达的转速
:param speed: 1000: 轻揉模式 2000:狂揉模式
:return:
'''
self.motorSpeed = speed
def wash(self):
if not self.hasClosed:
# 洗衣机门是否关闭 ,没有关闭 提示
print('请关闭洗衣机门,哔哔哔哔...')
elif self.__mode==0:
print('请设置模式')
else:
# 关闭了 执行下面的操作
print('放水...')
print('放满了...')
if self.__mode==1:
print('轻揉模式,洗内衣')
# 调节马达转速
self.__setMotorSpeed(1000)
print('马达转速:{}'.format(self.motorSpeed))
print('开始洗...')
elif self.__mode==2:
print('狂揉模式,洗外套')
# 调节马达抓霉素
self.__setMotorSpeed(2000)
print('马达转速:{}'.format(self.motorSpeed))
print('开始洗...')
print('洗完了')
|
封装的范围:
1.封装属性
2.封装成方法/函数
3.封装成类
4.封装模块和包
2. 继承
继承指的是一个对象直接使用另一个对象的属性或方法
继承的格式:
class 子类名(父类名):
...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | """------------------ 定义Person类 ------------------"""
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def sayHello(self):
print('hello')
"""------------------ 定义Student类继承Person ------------------"""
class Student(Person):
def __init__(self,name,age,id):
super(Student, self).__init__(name,age)
self.id = id
# 创建学生类
stu = Student('小明',15,'123')
# 访问属性
print(stu.name,stu.age,stu.id)
# 调用方法
stu.sayHello()
|
Student类继承自Person类
可以使用Person类中定义的属性name和age以及方法sayHello
3. 多继承
有多个父类的继承关系就称为多继承
多继承格式:
class 子类(父类1,父类2...)
...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | # 定义Mother类,Mother具有cook方法
class Mother:
def cook(self):
print('做饭')
# 定义Father类,Father具有makeMoney方法
class Father:
def makeMoney(self):
print('赚钱')
# 定义Son类
class Son(Mother, Father):
pass
# 创建Son对象
son = Son()
# 调用Mother的功能
son.cook()
# 调用Father的功能
son.makeMoney()
|
Son继承了Mother和Father
可以调用多个父类中的方法
4. 多态
多态指的是一类事物有多种形态（一个类有多个子类）
多态的概念依赖于继承
中国人、美国人、非洲人都是属于Human人类的子类
对于Human来说有多个子类就称为多态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 | # 父类
class Human:
def eat(self):
print('人类吃饭')
# 中国人
class ZhHuman(Human):
def eat(self):
print('中国人使用筷子吃饭')
# 美国人
class UsHuman(Human):
def eat(self):
print('美国人使用刀叉吃饭')
# 非洲人
class AfricaHuman(Human):
def eat(self):
print('非洲人直接用手吃恩希玛')
# 函数
def tranlate(human):
'''
接收一个具备吃放功能的Human对象
:param human:Human对象
:return:
'''
human.eat()
# 创建四个对象
human = Human()
zhHuman = ZhHuman()
usHuman = UsHuman()
africaHuamn = AfricaHuman()
# 调用translate方法
tranlate(human)
tranlate(zhHuman)
tranlate(usHuman)
tranlate(africaHuamn)
|
tranlate方法需要接收具备eat功能的Human对象,但是由于ZhHuman USHuman AfricaHuman都具备eat功能所以也可以传递到tranlate方法中
5. 鸭子模型
一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子“
对于上述的translate
1
2
3
4
5
6
7
8
9
10
11
12
13
14 | class Dog:
def eat(self):
print('狗吃骨头')
# 函数
def tranlate(human):
'''
接收一个具备吃饭功能的Human对象
:param human:Human对象
:return:
'''
human.eat()
dog = Dog()
tranlate(dog)
|
translate需要传递一个Human,但是Dog也具备eat功能,所以也可以传递运行
这是由于python是动态类型语言,不能像java等静态类型语言一样,限制传递的数据类型
只要运行时发现dog对象有这个功能,就可以在函数中使用