封裝

定義

將自己想要隱藏起來的內容隱藏起來

原則

• 將不需要隱藏起來的內容隱藏起來

• 將屬性隱藏起來，提供公共方法對其訪問

私有屬性：self.__屬性名

私有方法：def __函數名（self）:

私有靜態屬性：__靜態屬性名

對象.__dict__ :查看自己的屬性

class Teacher:
    __work = ‘jiangshi‘   #創建私有靜態屬性
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #創建自己的私有屬性
    def __jiang(self): #創建自己私有方法
        print(self.__jiang)
shi 
 
= Teacher(‘jing‘,20)
print(shi.__dict__)    

class Student:
    def __init__(self,name,id):
        self.name = name
        self.__id = id #  私有屬性創建
    def __learn(self):  # 私有方法創建
        print(self.__learn)
learn = Student(‘jing‘,2)
learn._Student__id = 6  #修改屬性 id
print(learn.__dict__)

調用自己的私有屬性、靜態屬性和方法加上（_類名）

私有方法還可以在類的內部使用

class Teacher:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd # 創建私有屬性
    def __jiang(self):  #創建私有方法
        print(‘1‘)
jiang = Teacher(‘jing‘,123)
jiang._Teacher__jiang()  # 調用自己的私有方法 前加“_類名”
print(jiang._Teacher__pwd)
jiang._Teacher__pwd = 789
 
 #調用修改私有屬性  前加‘_類名’
print(jiang.__dict__)  #查看自己的屬性

封裝的應用場景

封裝的好處

1. 提高安全性

2. 便於使用

父類的私有方法、靜態屬性、屬性都只能在自己內部調用 ，不能在子類中調用

面向對象常用的裝飾器

@property的作用

將一個類中的方法偽裝成一個屬性，調用時後面可以不用加括號

好處 ：

class Shop:
    discount = 
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property      #方法偽裝成一個屬性
    def price(self):
        return self.__price*self.discount  #私有屬性*折
    @price.setter  #將方法偽裝成屬性修改
    def price(self,new_price):
        self.__price = new_price
apple =Shop(‘apple‘,10)
print(apple.price)   
apple.price = 5  #調用不用加括號
print(apple.price)

classmethod ：類的裝飾器 將對象方法裝飾成類方法必須傳入一個參數（cls)

class A:
    @classmethod
    def func(cls):  #將對象的方法裝飾成類的方法
        print(‘func‘)
A.func()

staticmethod: 靜態方法裝飾器，將對象方法裝飾成靜態方法

class A:
    @staticmethod
    def func():
        print(‘func‘)
A.func()

面向對象的封裝方式

public:其實就是不封裝

private: 對誰都不公開

類裏共有三種定義方法：

1. 普通方法： self

2. 類方法 ： cls @classmethod

3. 靜態方法： @staticmethod

面向對象------封裝