面向对象2

一 面向对象的成员

1 面向对象的成员有三类：变量（字段)，方法，属性

 变量：实例变量（字段）：公有实例变量，私有实例变量

              类变量（静态字段）：公有类变量，私有类变量

class Foo:
      country='中国'           类变量（静态字段） 直接通过类访问Foo.country
      def __init__(self,name):      
             self.name=name      实例变量（字段）
       def func(self):

obj1=Foo('汪峰')
obj2=Foo('章子怡')

Foo.country


类变量可以通过对象调用 也可以用类调用


准则：实例变量（字段）访问时，使用对象访问:obj1.name
         类变量(静态字段)访问时，用类方法，即：Foo.country(实在不方便时，才使用对象访问)

print(obj1.name)
print(Foo.country)

2 什么时候用类变量？
当所有对象中有共同字段时且要改都改要删都删，可以将实例变量（字段）提取到类变量（静态字段）

3 公有与私有

公有的可以内部调用 也可以外部调用

私有的只要在前面加上__就变成私有的

私有的实例变量（私有字段）
class Foo:
       def __init__(self,name):
           #self.name=name    公有的
             self.__name=name   私有实例变量（私有字段）
             self.age=12
        def func(self)：
               print(self.__name)   内部可以访问私有的

obj=Foo('哈哈')
print(obj.age)
obj.__name  #无法访问
obj.func()    找一个内部人员：func,让func帮助你执行内部私有__name   



类变量（静态字段）
class Foo:
        country='中国'    #把country='中国'  改为__country='中国'   变成私有的
        def func(self):
           #内部调用
              print(self.coutry)   >>  self.__country
              print(Foo.country)   #推荐使用类方法访问类变量    >>  Foo.__country
 #外部调用
print(Foo.country)     #改为私有后外部不能调用

obj=Foo()
obj.func()

方法：（1）实例方法   （2）静态方法 （3）类方法

方法中也有公有和私有之分（成员修饰符）

1 实例化方法
class Foo(object):
        def __init__(self,name):
                self.name=name
         def func(self):   >>实例方法   self是对象
                 print(self.name)
obj=Foo()
obj.func()
                 



2 静态方法
class Foo(object):
        def __init__(self,name):
                self.name=name   实例化对象

         >>实例方法（至少有一个参数如self）
         def func(self):   
                 print(self.name)

         @staticmethod     >>静态方法(可以通过类调用和对象调用 推荐使用类调用) 可传参
         def display():
                 print('666')


obj.display()
Foo.display()



静态方法：如果方法中无需使用对象中封装的值，则使用静态方法
                 
总结：1 编写时：方法上方写@staticmethod  方法的参数可有可无
         2 调用时，直接使用类.方法名（） （推荐使用）   也可以使用对象调用  对象》方法名（）
         3 什么时候写静态方法
             如果方法中无需使用对象中封装的值，则使用静态方法



3 类方法
class Foo(object):

          @classmethod         类方法    至少有一个参数cls 也可以加参数
         def show(cls,x1,x2)
                  print(cls,'111')   cls 传递的是当前类   cls是类    

 Foo.show(1，8)    

结果 ：class '__main__'.Foo> 1  8



总结：1 类方法定义时：方法上方写：@classmethod  
                                方法的参数：至少有一个cls参数
         2 执行时：
                    类名.方法名（）  默认会将当前类传递到参数中
         3 什么时候用？
                      如果在方法中会使用到当前类就可以使用类方法       


         

属性 ：通过方法改造出来的

class Foo(object):
        def __init__(self):
              pass
       @property    >>属性
        def start(self):      只能有一个self  后面不能在加参数
              return 1
       @property
        def end(self):
               return 10
obj=Foo()
obj.start    不需要加括号  
obj.end


结果： 1
          10


编写时：方法上方写@property
调用时无需加括号   直接写对象.方法
应用场景：对于简单的方法，当无需传参时且有返回值