Python面向对象 | 类的成员

Posted 2020-11-22 summer-skr--blog

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python面向对象 | 类的成员相关的知识，希望对你有一定的参考价值。

一. 细分类的组成成员

之前咱们讲过类大致分两块区域，静态字段部分和方法部分。

每个区域详细划分又可以分为：

class A:

    company = ‘阿里巴巴‘          # 静态变量(静态字段)
    __tel = ‘xxxxxxx‘            # 私有静态变量(私有静态字段)

    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. 属性

　　静态属性

　　对象属性

静态字段(静态属性)

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

　　私有静态字段：仅类内部可以访问；

公有静态属性(字段)

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