资源简介

(共26张PPT)
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
少儿编程课
面向对象编程进阶
这一节，我们学习面向对象的三大特征：封装、继承和多态
三大特征之封装
什么是封装呢？我们用前面Orc类来说：
class Orc:
def __init__(self, name, hp, lv):
self.name = name
self.hp = hp
self.lv = lv
def desc(self):
print('我是%s，血量为：%s，等级为：%s' %
(self.name, self.hp, self.lv))
orc = Orc('史瑞克', 200, 2)
orc.desc()
在面向对象的编程思想中，将属性和方法隐藏在类中的行为，就称为封装。
属性和方法通过对象调用，对于调用者来说，隐藏了具体的实现细节。
封装除了隐藏细节外，还有另一个目的：数据的安全
就像机箱的目的是为了保护电脑内部的主板、硬盘、处理器、电源等
那么对于当前的Orc类来说，如何保证内部属性数据的安全呢？
class Orc:
def __init__(self, name, hp, lv):
self.name = name
self.hp = hp
self.lv = lv
def desc(self):
print('我是%s，血量为：%s，等级为：%s' % (self.name, self.hp, self.lv))
orc = Orc('史瑞克', 200, 2)
# 语法上没问题，但是不符合实际情况！
orc.hp = -200
orc.desc()
这就好比，如何能保证电脑内部硬盘的安全，同时又能够让外部能够访问到硬盘
对于电脑来说是机箱+USB接口，对于类来说，是私有+getter/setter
1
属性前加上__，就变成了了私有属性
class Orc:
def __init__(self, name, hp, lv):
self.__name = name
self.__hp = hp
self.__lv = lv
def desc(self):
print('我是%s，血量为：%s，等级为：%s' %
(self.__name, self.__hp, self.__lv))
orc = Orc('史瑞克', 200, 2)
orc.desc()
# 此时打印,会报错
print(orc.__hp)
Traceback (most recent call last):
File "C:/…/demo01.py", line 13, in
print(orc.__hp)
AttributeError: 'Orc' object has no attribute '__hp'
此时运行（类外部访问），就会报错
2
外部如何访问属性呢？比如获取当前的血量
class Orc:
def __init__(self, name, hp, lv):
self.__name = name
self.__hp = hp
self.__lv = lv
def desc(self):
print(‘我是%s，血量为：%s，等级为：%s’ %
(self.__name, self.__hp, self.__lv))
# get方法
def get_hp(self):
return self.__hp
orc = Orc('史瑞克', 200, 2)
orc.desc()
# get方法的使用
print(orc.get_hp())
这就是所谓的属性的getter方法
那又该如何在外部修改属性的值呢？比如血量减少之后hp的重新赋值
3
这就是和getter对应的setter方法，类定义如下：
外部访问过程如下：
class Orc:
def __init__(self, name, hp, lv):
self.__name = name
self.__hp = hp
self.__lv = lv
def desc(self):
print('我是%s，血量为：%s，等级为：%s' %
(self.__name, self.__hp, self.__lv))
def get_hp(self):
return self.__hp
def set_hp(self, hp):
self.__hp = hp
orc = Orc('史瑞克', 200, 2)
orc.desc()
# 模拟orc这个对象减少了50点血
orc.set_hp(150)
orc.desc()
print(orc.get_hp())
我是史瑞克，血量为：200，等级为：2
我是史瑞克，血量为：150，等级为：2
150
输出结果为：
思考：使用私有+getter/setter为什么解决数据安全的问题？
为什么说私有+getter/setter就解决了数据的安全（脏数据）问题呢？
关键在setter方法上，在该方法中，我们可以做任何的处理，比如对hp小于0的赋值都置为0：
class Orc:
……
def set_hp(self, hp):
if hp < 0:
self.__hp = 0
else:
self.__hp = hp
orc = Orc('史瑞克', 200, 2)
orc.desc()
# 模拟orc这个对象减少了50点血
orc.set_hp(-150)
orc.desc()
print(orc.get_hp())
我是史瑞克，血量为：200，等级为：2
我是史瑞克，血量为：0，等级为：2
0
运行结果为：
三大特征之继承
现在假设我们做一个学校管理系统，那么就可能会要新建两个类
1
教师类，属性有：姓名、年龄、职位等
2
学生类，属性有：姓名、年龄、专业等
class Teacher:
def __init__(self, name, age, position):
self.__name = name
self.__age = age
self.__position = position
def desc(self):
print('大家好，我是一名教师，'
'我叫%s，今年%s岁，目前职位为：%s' %
(self.__name, self.__age, self.__position))
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def get_position(self):
return self.__position
def set_name(self, name):
self.__name = name
def set_age(self, age):
self.__age = age
def set_position(self, position):
self.__position = position
class Student:
def __init__(self, name, age, major):
self.__name = name
self.__age = age
self.__major = major
def desc(self):
print('大家好，我是一名学生，'
'我叫%s，今年%s岁，在读专业为：%s' %
(self.__name, self.__age, self.__major))
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def get_major(self):
return self.__major
def set_name(self, name):
self.__name = name
def set_age(self, age):
self.__age = age
def set_major(self, major):
self.__major = major
可以发现这两个类中有很多重复的地方，比如name和age属性及其get/set方法
age
name
position
教师类
age
name
major
学生类
age
name
position
major
教师类
学生类
把共同部分提取出来
这样有什么好处呢？代码进行了复用！
age
name
position
major
age
name
position
教师类
age
name
major
学生类
age
name
dept
后勤人员类
dept
父类
子类
实际子类
下面我们来看下Python中继承的写法，还以教师类和学生类来说：
1
定义父类，包含name和age属性
2
定义Teacher类，继承Person类
class Person:
def __init__(self, name, age):
self.__name = name
self.__age = age
def desc(self):
print('我是父类，姓名：%s,年龄：%s' % (self.__name, self.__age))
class Teacher(Person):
def __init__(self, name, age, position):
# super():用于调用父类的方法
super().__init__(name, age)
self.__position = position
teacher = Teacher('张三', 20, 'aaa')
teacher.desc()
这样，属性和方法都继承了过来
练习
Exercises
密
封
线
内
不
准
答
题
编写Student类，继承自Person类
三大特征之多态
现在，我们用上一步的Person、Teacher和Student来看下什么是多态
2
使用teacher对象调用desc()，
1
在Person中提供name和age的getter/setter
class Teacher(Person):
def __init__(self, name, age, position):
# super():用于调用父类的方法
super().__init__(name, age)
self.__position = position
teacher = Teacher('张三', 20, 'aaa')
teacher.desc()
这样输出的是父类的desc()
3
在Teacher类中添加desc方法，类似如下：
def desc(self):
print('我是一名教师，名字：'
'%s，年龄：%s，职位：%s'
% (super().get_name(), super().get_age(), self.__position))
练习
Exercises
密
封
线
内
不
准
答
题
添加Student类中的desc()方法，注意super()的使用！
现在，让我们再次来运行teacher或student对象的desc()方法，以teacher为例：
代码为：
teacher = Teacher('张三', 20, '教研组长')
teacher.desc()
运行结果为：
我是一名教师，名字：张三，年龄：20，职位：教研组长
也即是说，子类的desc方法覆盖了父类的desc方法，当调用的时候，调用的是子类的方法，这就叫多态
这个该如何去理解呢？举个例子，下面的图片，都是鸟
用面向对象的思想来看，是这样的：
父类：鸟类
子类：麻雀类
子类：鹦鹉类
子类：老鹰类
长羽毛()
长…羽毛()
长…羽毛()
长…羽毛()
生态学角度来看，这就是生物的多样性
那么多态有什么好处呢？比如你想查看所有鸟类羽毛的颜色
不管有多少种鸟（子）类，只需要定义一个方法
就能查看所有鸟的颜色了。
因为此时调用羽毛颜色()方法，实际调用的是子类
重写后的羽毛颜色()方法。
同时符合面向对象6大设计原则中的对扩展开放、
对修改关闭原则。
不使用多态的情况下：
def 查看羽毛颜色(麻雀):
print(‘羽毛颜色为：%s’ % 麻雀.羽毛颜色())
def 查看羽毛颜色(鹦鹉):
print('羽毛颜色为：%s' % 鹦鹉.羽毛颜色())
def 查看羽毛颜色(老鹰):
print('羽毛颜色为：%s' % 老鹰.羽毛颜色())
使用多态的情况下：
def 查看羽毛颜色(鸟):
print('羽毛颜色为：%s' % 鸟.羽毛颜色())
最后，我们用一句话来总结面向对象的编程实现
由现实中的对象，抽象得到程序中的类，使用类来创建程序中的对象，使用对象的方法来编写具体的业务。
因为数据的安全性和方便性，有了封装，为了代码的复用，有了继承，继承就有父子类，子类会重写父类的
方法，有了重写，就有了多态，多态是为了统一处理某一类信息方便，同时方便了软件的扩展（对扩展开放）。
总结
Summary
面向对象三大特征：封装、继承、多态
√
super关键字的理解和使用
√
Thanks!

展开更多......

收起↑