Python之面向对象（五）类的成员

面向对象之：类的成员

1. 细分类的组成成员

   • 类大概分为两块区域，如下

   • class A:
         name="haha"#第一部分 静态字段（静态变量）
         
         def __init__(self):#第二部分 方法部分
             pass
         def func(self):#第二部分：方法部分
             pass
     

   • 具体可以细分为：

   • class A:
         company_name="haha" #静态变量 (静态字段)
         _iphone="564545"#私有静态变量（私有静态字段）
         
         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
     

2. 类的私有成员

   • 对于每个类的成员而言都有两种形式：公有成员：在任何地方都能访问；私有成员，只有在类的内部才能访问

   • 私有成员和公有成员的访问限制不同：

   • 静态字段（静态属性）

     • 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问

     • 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()  # 派生类中访问  ==> 错误
       

   • 方法：

     • 公有方法：对象可以访问；类内部可以访问；派生类可以访问

     • 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()  # 派生类中访问  
       

     • 私有方法：仅类内部可以访问

     •     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()  # 派生类中不能访问
       

   • 总结：对于这些私有成员来说,他们只能在类的内部使用,不能再类的外部以及派生类中使用.

     ps：非要访问私有成员的话，可以通过 对象._类__属性名,但是绝对不允许!!!

3. 类的其他成员：这里的其他成员主要就是类方法：方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

   • 实例方法：
     • 定义：第一个参数必须是实例对象，该参数名一般约定为:"self"，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
     • 调用：只能由实例对象调用
   • 类方法：
     • 定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为"cls"，通过它来穿打底类的属性和方法（不能传实例的属性和方法）；
     • 调用：实例对象和类对象都可以调用
   • 静态方法：
     • 定义：使用装饰器@staticmethod.参数随意，没有"self"和"cls"参数，但是方法体中不能使用类或实例的任何属性和方法；
     • 调用：实例对象和类对象都可以调用