面向对象之总结

一,面向对象结构与成员

1,1 面向对象结构分析:

那么每个大区域又可以分为多个小部分:

class A:

company_name = '软银集团' # 静态变量(静态字段)
__iphone = '1353333xxxx' # 私有静态变量(私有静态字段)

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

类的结构细分

类有这么多的成员,那么我们先从那些地方研究呢? 可以从私有与公有部分,方法的详细分类两个方向去研究.

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

公有方法

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

私有方法

总结:

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

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

为什么可以通过._类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法)它会将其保存在内存时自动在前面加上_类名.

1.3面向对象的成员

1.3.1 字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

• class Foo:

  def __init__(self, name):
  self.name = name

  def ord_func(self):
  """ 定义普通方法，至少有一个self参数 """

  # print self.name
  print '普通方法'

  @classmethod
  def class_func(cls):
  """ 定义类方法，至少有一个cls参数 """

  print '类方法'

  @staticmethod
  def static_func():
  """ 定义静态方法 ，无默认参数"""

  print '静态方法'

  
  # 调用普通方法
  f = Foo()
  f.ord_func()

  # 调用类方法
  Foo.class_func()

  # 调用静态方法
  Foo.static_func()

  分别示例

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。