2. 程式人生 > >day6面向對象

day6面向對象

阿新 • • 發佈：2017-07-29
call clas code 共同點 自動 同時 結束 ack 釋放

面向對象介紹(http://www.cnblogs.com/alex3714/articles/5188179.htm)

世界萬物，皆可分類

世界萬物，皆為對象

只要是對象，就肯定術語某種類

　　（1）特性 封裝、繼承、多態

Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含著類的數據和方法

Inheritance 繼承
　　一個類可以派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承

Polymorphism 多態
　　多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。
編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。
　　對不同類的對象發出相同的消息將會有不同的行為。比如，你的老板讓所有員工在九點鐘開始工作, 他只要在九點鐘的時候說：“開始工作”即可，而不需要對銷售人員說：“開始銷售工作”，對技術人員說：“開始技術工作”, 因為“員工”是一個抽象的事物, 只要是員工就可以開始工作，他知道這一點就行了。至於每個員工，當然會各司其職，做各自的工作。
多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象可以在運行期間動態綁定

class

object

(2）語法 屬性、方法、構造函數、析構函數

私有方法，私有屬性

創建類，並實例化兩個對象 

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name      #實例變量(靜態屬性）
        self.role = role
        self.weapon = weapon
        self.life_value 
 
= life_value
        self.money = money

    def shot(self):                         #方法(動態屬性）
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex
 
","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色
r1.buy_gun("AK47")

把一個類變成一個具體對象的過程叫實例化。

__init__(self)：構造函數，作用是在實例化時做一些類的初始化工作。

r1 = Role("alex","police","AK47") #實例化，又可以稱為初始化分類與Role("alex","police","AK47")是一樣的，賦給一個變量的目的是防止被銷毀，python的內存回收機制，如果沒有變量，開辟的內存將會被回收。

調用r1 = Role("alex","police","AK47")等價於Role(r1,"alex","police","AK47")其中，self相當於r1，把r1當做參數傳進去了。

技術分享

上面實例化過程中，self相當於r1，self.name等價於r1.name。每次實例化，都會把實例化的名字傳進去，r1 = Role("alex","police","AK47") 》Role(r1,"alex","police","AK47"), r2 = Role("jack","terroist","B15")》Role(r2,"jack","terroist","B15")

　　r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
　　r2 = Role("jack","terroist","B15")   #生成一個角色
　　r1.buy_gun("AK47")
    r2.get_shot()   #調用r2相當於Role.get_shot(r2)

上面調用的過程中，r2.get_shot()相當於Role.get_shot(r2)。實例變量的作用域就是實例本身。

類中的函數叫方法；

類變量和實例變量的方法： 

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

# r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
# r2 = Role("jack","terroist","B15")   #生成一個角色

print(Role.n)

上面代碼中，我們給類添加了一個變量n，可以發現，我們沒有創建實例，就可以調用，說明n是存在類變量中的。

下面創建實例，看是否可以調用：

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色

print(Role.n)
print("r1.n:",r1.n)

上面，實例裏面不包含n，但是也可以了，說明實例沒有這個變量會去類裏面找。

現在我們創建了一個name的類變量，由於實例裏面也包含name屬性。看是調用那個方法。

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色

print(Role.n)
print("r1.n:",r1.n)
print("r1.name:",r1.name)
運行結果如下
123
r1.n: 123
r1.name: alex

從上面代碼可以看出，先去實例裏面找變量，如果沒有才會去類中進行查找。

下面給類修改變量。

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r1.name = "chenronghua"     #給實例修改名字
r2 = Role("jack","terroist","B15")   #生成一個角色
r2.name = "小豬豬"    #給實例重新進行賦值

print(Role.n)
print("r1.n:",r1.n)
print("r1.name:",r1.name)
運行結果如下：
123
r1.n: 123
r1.name: chenronghua

從上面可以看出，實例化之後，我們可以給實例化的變量重新賦值，修改裏面的值。

下面我們給實例本身添加一個新的屬性： 

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r1.name = "chenronghua"
r1.bullet_vests = True       #屬性不存在，重新創建一個屬性
r2 = Role("jack","terroist","B15")   #生成一個角色
r2.name = "小豬豬"

print("bullet_vests",r1.bullet_vests)
print("r2.bullet_vests:",r2.bullet_vests)
運行結果如下：
bullet_vests True
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 29, in <module>
    print("r2.bullet_vests:",r2.bullet_vests)
AttributeError: ‘Role‘ object has no attribute ‘bullet_vests

上面，我們給r1實例創建了一個bullet_vests的新屬性，可以看出，能夠給實例r1創建新的屬性，創建的屬性r2實例是不具備的。

下面來刪除實例裏面的變量：刪除r1實例中的weapon

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r1.name = "chenronghua"
del r1.weapon      #刪除實例r1中的weapon
r2 = Role("jack","terroist","B15")   #生成一個角色
r2.name = "小豬豬"

print(r2.weapon)
print(r1.weapon)
運行結果如下：
B15
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 29, in <module>
    print(r1.weapon)
AttributeError: ‘Role‘ object has no attribute ‘weapon

從運行結果可以看出，刪除實例r1中的weapon之後，實例r2中的weapon不受影響，但是實例r1中的weapon不存在了。

如果我們刪除Role類中的weapon，那麽肯定r1.weapon和r2.weapon都不能調用。

下面來看一下，實例裏面是否可以修改類變量：

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r1.name = "chenronghua"
r1.n = "666可以改嗎"       #修改類中的變量，看是否可以成功
r2 = Role("jack","terroist","B15")   #生成一個角色
r2.name = "小豬豬"

print("r1.n:",r1.n)
print("r2.n:",r2.n)
運行結果如下：
r1.n: 666可以改嗎
r2.n: 123

從上面代碼可以看出，r1.n="666可以改嗎"等於在實例r1中重新創建了一個變量n，因為實例r1中不存在n，不影響類本身Role.n中的值。

類內存和類生成的實例內存。

類變量的用途？大家共用的屬性，節省開銷。比如防彈衣，默認是沒有穿防彈衣的，我們可以在類中定義一個bullet_vests=""，這樣，每個人都具有了防彈衣的屬性。當某人買了放單衣的時候，直接r1.bullet_vests=True即可。雖然可以在屬性裏面定義，但是這樣每個屬性裏面都創建了bullet_vests，浪費了內存。在類中只需創建一次即可。

析構函數

析構函數：在實例釋放、銷毀的時候執行的，通常用於做一些收尾工作，如關閉一些數據庫鏈接，打開的臨時文件，可以在裏面進行操作。

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def __del__(self):     #不需要傳參數，實例結束之後自動執行,不用調用直接執行    析構函數
        print("%s 徹底死了" %self.name)

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r1.name = "chenronghua"
r1.n = "666可以改嗎"
r2 = Role("jack","terroist","B15")   #生成一個角色
r2.name = "不努力"


r1.get_shot()
r2.shot()
運行結果如下：
ah....,I got shot......
shotting.......
chenronghua 徹底死了
不努力 徹底死了

從上面代碼可以看出，__del__析構函數在程序退出的時候自動執行。就是在我們運行玩類之後，自動銷毀變量。是在所有調用結束不使用的時候才銷毀的。

__del__析構函數不需要自己調用，在程序調用結束後自動執行。

私有方法，私有屬性

私有方法，私有屬性：就是只能內部訪問，外部訪問不了。

比如上面類中的self.life_value屬性，我們知道，任何人執行程序都可以調用r1.life_value=0,直接讓生命值變為0，如下：

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def __del__(self):     #不需要傳參數，實例結束之後自動執行,不用調用直接執行
        print("%s 徹底死了" %self.name)

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色

print("modify before:",r1.life_value)
r1.life_value = 0
print("modify after:",r1.life_value)
運行結果如下：
modify before: 100
modify after: 0
alex 徹底死了
jack 徹底死了

從上面代碼可以看出，開始的時候r1.life_value生命值是100滿的，但是我們修改了生命值，直接讓生命值變成0；可以看出，生命值直接改變了。假如是一款遊戲的話，上來直接別人修改生命值就掛了，還沒有摸過女生的屁股就死了，這他媽也太冤枉了吧。所以，這樣肯定是不行的，不能讓外部調用機密的屬性，只能在內部進行調用。如下：

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value
        self.money = money

    # def __del__(self):     #不需要傳參數，實例結束之後自動執行,不用調用直接執行
    #     print("%s 徹底死了" %self.name)

    def show_status(self):
        print("name:%s weapon:%s life_value:%s" %(self.name,self.weapon,self.__life_value))

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色
print(r1.__life_value)
運行結果如下：
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 30, in <module>
    print(r1.__life_value)
AttributeError: ‘Role‘ object has no attribute ‘__life_value‘

從上面運行結果可以看出，當我們把變量life_value設置為私有變量__life_value的時候，外部是不能夠調用的。錯誤提示是：Role類中沒有__life_value屬性。

既然私有屬性不能在外部調用，那麽我們就在程序內部調用。

class Role(object):
    ‘‘‘創建一個角色的類‘‘‘
    n = 123    #類的變量，存在類的內存中
    name = "我是類name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        ‘‘‘初始化變量‘‘‘
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value
        self.money = money

    # def __del__(self):     #不需要傳參數，實例結束之後自動執行,不用調用直接執行
    #     print("%s 徹底死了" %self.name)

    def show_status(self):
        ‘‘‘通過內部調用私有屬性‘‘‘
        self.__life_value -= 50
        print("name:%s weapon:%s life_value:%s" %(self.name,self.weapon,self.__life_value))

    def shot(self):
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #實例化，又可以稱為初始化分類
r2 = Role("jack","terroist","B15")   #生成一個角色
r1.show_status()     #通過函數內部調用私有屬性
運行結果如下：
name:alex weapon:AK47 life_value:50

上面代碼，我們在類內部新增了一個方法，用來調用私有屬性，可以看出，在內部是可以調用私有屬性的。並且能夠正常調用執行私有屬性。

因此，私有屬性是能夠調用的，只是需要在程序內部執行。在外部是不能調用的。這種情況適用於很多時候，比如我們不希望別人查看我們的密碼，銀行賬號，一些私有的屬性，都可以通過設置這種私有屬性的方法來規避。

也可以設置私有方法，只需要在前面添加__get_shot(self)就設置了一個私有方法，私有方法在外部是不能夠調用的。

day6面向對象

相關推薦

Python之路,Day6 - 面向對象學習

粘貼 實現繼承 png 情況 面向對象的特征 可用性 image 相同屬性 使用 面向過程 VS 面向對象 編程範式 編程是 程序 員 用特定的語法+數據結構+算法組成的代碼來告訴計算機如何執行任務的過程 ， 一個程序是程序員為了得到一個任務結果而編寫的一組指令的集合，

day6面向對象

call clas code 共同點 自動 同時 結束 ack 釋放 面向對象介紹(http://www.cnblogs.com/alex3714/articles/5188179.htm) 世界萬物，皆可分類 世界萬物，皆為對象 只要是對象，就肯定

day6面向對象--繼承、多態

進行 ... 自己 rec trac col file error: friends 繼承 繼承：就像遺傳一樣，繼承就是擁有父類的所有方法和屬性，並且能夠定義自己獨特的屬性和方法，對上面的類進行擴展。 可以什麽都不寫，直接繼承父類，如下： clas

day6面向對象--類的特殊成員方法

doc tel func 信息 成員方法 self div mod 輸出 類的特殊成員方法 1. __doc__　　表示類的描述信息 class Func(object): ‘‘‘__doc__方法是用來打印類的描述信息‘‘‘ def tell(

day6--面向對象初識

動態 構造 work DC 類定義 方法 減少 soup 所有 一面向過程與面向對象 面向過程： 流水線式的思維，順著流程進行下去，類似於代碼的堆疊，重視步驟 優點：不需要考慮太多東西，想到一個功能就寫一個功能，堆疊代碼 缺點：過程往往是先後執行的，要想變換功能或者增加功能

Mooc軟件工程-02面向對象泛型

組成 ima 固然是 name 成員 專註 對象 指示 類的繼承 1 內聚 　　模塊 　　　　語義上連續的一系列語句, 由邊界符界定, 並且有一個聚集標識符 　　常見的模塊 　　　　在面向對象中的 類, 方法 　　　　在面向過程的 函數 　　模塊功能單一, 內部

JS面向對象，創建，繼承

request 瀏覽器 cookie 1 創建一個面向對象var obj = new Object(); //創建一個空對象obj.name = ‘haha‘; obj.showName = function(){ alert(obj.name); } obj.showName();缺點：

面向對象關於函數以及this的問題

argument 實例對象 show urn foo 返回值 nload 改變 定義 函數在js中扮演的角色 1、普通函數 function foo(){ console.log(1); } foo(); 2、構造函數

2017.05.06FreeCodeCamp編程之JS面向對象編程學習

支持 concat lte red true 轉化 指向 -1 方法的參數 1.構造對象的方法： ① ②使用構造函數來創建對象。構造函數 通常使用大寫字母開頭，以便把自己和其他普通函數區別開。 在 構造函數 中， this 指向被此 構造函數 創建出來的 對象 。

JavaScript面向對象編程（9）高速構建繼承關系之整合原型鏈

eight family per ria code prot style triangle super 前面我們鋪墊了非常多細節。是為了讓大家更加明晰prototype的使用細節； 如今能夠將前面的知識整合起來，寫一個函數用於高速構建基於原型鏈的繼承關系了： funct

JavaScript設計模式：一、面向對象編程

this 依賴 人在 turn obj log javascrip 體會 創建 JavaScript面向對象編程 眾所周知，JS作為一門腳本語言，由於其設計者在設計JS的時候，也僅僅用了很少的時間就完成了JS這門語言的創建，JS雖然擁有著腳本語言的優勢，但是JS也存在著

【php】面向對象（一）

打電話 成員方法 駝峰命名 bject 內部 自動 正在 自己 div 1. 學習面向對象的目標：　　a) 語法的學習：　　b) 編程思想的學習：　　　　i. 過程化：　　　　ii. 面向對象：2. 比較（有對象和沒對象的區別）　　a) 沒對象：　　　　i. 我餓了 自己

面向對象-構造函數-優化-方案1

對象 style ont code new blog var cnblogs spa 1 //優化前 2 function Person (name,age){ 3 this.name=name; 4 this.age=

JavaScript設計模式：一、面向對象編程（第二節）

得到 調用 帶來 方式 get 特權 style 方法封裝 面向對象 一、封裝 面向對象編程思想其中的一個特點就是封裝，通俗的講法就是把需要的功能方向在一個對象裏。遺憾的是，對於JS這種解釋性的弱類型語言沒有經典強類型語言中那樣通過class等關鍵字實現類的封裝方法，j

【php】面向對象（五）

row 操作類 面向對象 ssa getline var pre span 錯誤信息 一、 類型約束：　　a) 約束函數可傳入的參數類型二、 類的遍歷　　a) Foreach　　b) 可以將類當中的所有成員屬性遍歷出來三、 關於操作類與對象的一些函數：　　a) 判斷函數　　

ECMAScript面向對象(二)——之創建對象方法總結

擴展 console 動態 原型 struct 私有屬性 true asc 一份 創建對象的方法 工廠模式 缺點：無法識別對象的類型，因為根本沒有定義新的對象類型 // 工廠模式創建對象 //定義 function createPerson(name,age,

【php】面向對象（三）

lamp1 變量 步驟 efi 第一個 面向對象 我們 ati 單例 知識點關鍵詞：FSCICATS一、 f => final：　　a) 是一個修飾符，用來修飾類和成員方法　　b) 使用final修飾符修飾的類不能被繼承，使用final修飾符修飾的成員方法，不能被重寫

Java面向對象16種原則

避免 design 代碼 war 裏氏替換原則 類圖 系統 依賴倒置原則 調用 一 類的設計原則 1　依賴倒置原則－Dependency Inversion Principle (DIP) 2　裏氏替換原則－Liskov Substitution Principle

面向對象繼承

extends pro 訪問 常見 面試題 派生 常見面試題 同時存在 ava 第一次課 一、 繼承的優點 優點：提高代碼的可重用性 1、 如何判斷A、B類之間是繼承關系？ 符合 is…a關系 2、java中，所有的類都直接或間接的繼承了java.

面向對象抽象封裝

控制語句 菜單 修飾符 ret setters pri 面向對象設計 類型 setter ? 第一章第一次課? 使用類圖如何描述設計 - private(私有) 屬性+ public(公共) 方法訪問修飾符：缺省（默認），只能被同一個包中的類訪問private（私有的