資源簡介

(共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!

展開更多......

收起↑