封裝

面向對象三大特性： 繼承 封裝 多態

隱藏對象的屬性和實現細節，僅對外提供公共訪問方法

廣義上的封裝 : 把方法和變量都封裝在類中

狹義上的封裝 : 在類的外部干脆不能調用了

優點

1. 將變化隔離
2. 便于使用
3. 提高復用性
4. 提高安全性

封裝原則：

• 將不需要對外提供的內容隱藏起來
• 把屬性都隱藏，提供公共方法對齊訪問

私有變量和私有方法

在python中用雙下劃線開頭的方式將屬性隱藏起來（設置成私有的）

代碼實例

          
            # 其實這僅僅這是一種變形操作
# 類中所有雙下劃線開頭的名稱如__x都會自動變形成：_類名__x的形式：

class Student:
    def __init__(self,name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self,value):
        if type(value) is str:
            self.__name =value
            
mhy = Student('mhy')
print(mhy.get_name())
mhy.set_name('alex')
print(mhy.get_name())
print(mhy.__name)


#A._Student__name是可以訪問到的，即這種操作并不是嚴格意義上的限制外部訪問，僅僅只是一種語法意義上的變形
# print(mhy.__dict__) 查看該類的屬性,可以看到__name變成{'_Student__name': 'alex'}
# 屬性封裝
class Person:
    def __init__(self,username,password):
        self.username = username
        self.__password = password

p = Person('alex','alex3714')
print(p.username)

# 類變量封裝
class A:
    __val = []
    def __init__(self):
        print(A.__val)   #只有在類內部才可以通過__val的形式訪問到.

A()
print(A.__val)

# 類方法封裝
class A:
    def func(self):
        self.__aaa()
    def __aaa(self):
        print('aaa')

a = A()
a.func()
          
        

這種自動變形的特點 ：

1.類中定義的x只能在內部使用，如 self.x ，引用的就是變形的結果。

**2.這種變形其實正是針對外部的變形，在外部是無法通過__x這個名字訪問到的。**

**3.在子類定義的__x不會覆蓋在父類定義的__x，因為子類中變形成了：_子類名__x,而父類中變形成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是無法覆蓋的。**

這種變形需要注意的問題是：

***1.這種機制也并沒有真正意義上限制我們從外部直接訪問屬性，知道了類名和屬性名就可以拼出名字：_類名__屬性，然后就可以訪問了，如a._A__N***

2.變形的過程只在類的內部生效,在定義后的賦值操作，不會變形

3.在繼承中，父類如果不想讓子類覆蓋自己的方法，可以將方法定義為私有的

          
            #把fa定義成私有的，即__fa
>>> class A:
...     def __fa(self): #在定義時就變形為_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只會與自己所在的類為準,即調用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A
          
        

封裝與擴展性

封裝在于明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。這就提供一個良好的合作基礎——或者說，只要接口這個基礎約定不變，則代碼改變不足為慮。

          
            #類的設計者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏了內部的實現細節，此時我們想求的是面積
        return self.__width * self.__length


#使用者
>>> r1=Room('臥室','egon',20,20,20)
>>> r1.tell_area() #使用者調用接口tell_area


#類的設計者，輕松的擴展了功能，而類的使用者完全不需要改變自己的代碼
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏內部實現，此時我們想求的是體積,內部邏輯變了,只需求修該下列一行就可以很簡答的實現,而且外部調用感知不到,仍然使用該方法，但是功能已經變了
        return self.__width * self.__length * self.__high


#對于仍然在使用tell_area接口的人來說，根本無需改動自己的代碼，就可以用上新功能
>>> r1.tell_area()