• 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"参数,但是方法体中不能使用类或实例的任何属性和方法;
        • 调用:实例对象和类对象都可以调用
  • 相关阅读:
    go语言笔记——append是内置的函数!!!new是一个函数!!!调试可以使用闭包,本质上是print调试,尼玛!
    go语言笔记——defer作用DB资源等free或实现调试
    提高mysql查询效率的六种方法
    无线网络wifi (WPA/WPA2)密码破解方法
    wifi密码破解方法总结(含破解软件下载链接)
    linux 创建账户
    vim中设置tab的长度的方法
    JAVAC 命令使用方法
    Linux环境下编译并执行ava helloworld程序
    java hadoop file system API
  • 原文地址:https://www.cnblogs.com/zhangdadayou/p/11415367.html
Copyright © 2020-2023  润新知