Python面向對象 | 類的成員

時間 2019-11-15

原文原文鏈接

一. 細分類的組成成員

以前我們講過類大體分兩塊區域，靜態字段部分和方法部分。python

每一個區域詳細劃分又能夠分爲：程序員

class A:

    company = '阿里巴巴'          # 靜態變量(靜態字段)
    __tel = '400xxxxx'              # 私有靜態變量(私有靜態字段)

    def __init__(self,name,age):             #特殊方法（初始化方法）
        self.name = name              # 對象屬性(普通字段)
        self.__age = age                  # 私有對象屬性(私有普通字段)

    def func1(self):                  # 普通方法
        pass

    def __func(self):                 #私有方法
        print(666)

    @classmethod                  # 類方法
    def class_func(cls):
        """ 定義類方法，至少有一個cls參數 """
        print('類方法')

    @staticmethod                  #靜態方法
    def static_func():
        """ 定義靜態方法 ，無默認參數"""
        print('靜態方法')

    @property                      # 屬性
    def prop(self):
        pass

二. 類的私有成員

對於每個類的成員而言都有兩種形式：spa

　　公有成員，在任何地方都能訪問code

　　私有成員，只有在類的內部才能方法對象

私有成員和公有成員的訪問限制不一樣blog

1. 屬性

　　靜態屬性內存

　　對象屬性開發

靜態字段(靜態屬性)源碼

　　公有靜態字段：類能夠訪問；類內部能夠訪問；派生類中能夠訪問it

　　私有靜態字段：僅類內部能夠訪問；

公有靜態屬性(字段)

class C:
    name = "公有靜態字段"

    def func(self):
        print C.name

class D(C):
    def show(self):
        print C.name

C.name             # 類訪問

obj = C()
obj.func()         # 類內部能夠訪問

obj_son = D()
obj_son.show()     # 派生類中能夠訪問

私有靜態屬性(字段)

class C:
    __name = "私有靜態字段"

    def func(self):
        print C.__name


class D(C):
    def show(self):
        print C.__name

C.__name       # 不可在外部訪問

obj = C()
obj.__name      # 不可在外部訪問
obj.func()         # 類內部能夠訪問   

obj_son = D()
obj_son.show()     #不可在派生類中能夠訪問

公有對象屬性

class C:
    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print self.foo 　#　類內部訪問


class D(C):   
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.foo     # 經過對象訪問
obj.func()  # 類內部訪問

obj_son = D();
obj_son.show()  # 派生類中訪問

私有對象屬性

class C:
    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print self.foo 　#　類內部訪問


class D(C):
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.__foo     # 經過對象訪問    ==> 錯誤
obj.func()  # 類內部訪問        ==> 正確

obj_son = D();
obj_son.show()  # 派生類中訪問  ==> 錯誤

2. 方法

　　公有方法:對象能夠訪問；類內部能夠訪問；派生類中能夠訪問

　　私有方法:僅類內部能夠訪問；

（1）公有方法

class C:
    def __init__(self):
        pass
    
    def add(self):
        print('in C')


class D(C):
    def show(self):
        print('in D')
        
    def func(self):
        self.show()
obj = D()
obj.show()  # 經過對象訪問   
obj.func()  # 類內部訪問    
obj.add()  # 派生類中訪問

（2）私有方法

class C:
    def __init__(self):
        pass

    def __add(self):
        print('in C')


class D(C):
    def __show(self):
        print('in D')

    def func(self):
        self.__show()
obj = D()
obj.__show()  # 經過不能對象訪問
obj.func()  # 類內部能夠訪問
obj.__add()  # 派生類中不能訪問