Python面向对象（公有与私有）

面向对象的私有与公有

对于每一个类的成员而言都有两种形式：

公有成员，在任何地方都能访问

私有成员，只有在类的内部才能方法

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

静态字段(静态变量)

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

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

公有静态字段

class A:

    name = "公有静态字段"

    def func(self):

        print(A.name)

class B(A):

    def show(self):

        print(A.name)

print(A.name)    #类访问

obj = A() 

obj.func()       #类内部可访问

obj_son = B()

obj_son.show()   #派生类中可访问

私有静态字段

class A:

    __name = "私有静态字段"

    def func(self):

        print(A.__name)

class B(A):

    def show(self):

        print(A.__name)

obj = A()

obj_2 = B()

#print(obj.__name)   #在外部访问报错

obj.func()  #类内部可以访问

obj_2.show()  #不可在派生类中访问

AttributeError: type object 'A' has no attribute '_B__name'

普通字段(对象属性)

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问

私有普通字段：仅类内部可以访问；

公有普通字段

class A:

    def __init__(self):

        self.foo = "公有字段"

    def func(self):

        print(self.foo)

class B(A):

    def show(self):

        print(self.foo)

obj = A()

print(obj.foo)

obj.func()

obj_2 = B()

obj_2.show()

私有普通字段

class A:

    def __init__(self):

        self.__foo = "私有字段"

    def func(self):

        print(self.__foo)

class B(A):

    def show(self):

        print(self.__foo)

obj = A()

# print(obj.__foo)   #外部访问报错

obj.func()   #类内部访问

# obj_2 = B()

# obj_2.show()  #派生类中访问报错

方法

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

私有方法:仅类内部可以访问；

公有方法

class A:

    def __init__(self):

        pass

    def add(self):

        print('A')

class B(A):

    def show(self):

        print("B")

    def func(self):

        self.show()

obj = B()

obj.show()

obj.func()

obj.add()

私有方法

class A:

    def __init__(self):

        pass

    def __add(self):

        print('A')

class B(A):

    def __show(self):

        print("B")

    def func(self):

        self.__show()

obj = B()

obj.__show()   #不能访问

obj.func()    #能访问

obj.__add()  #不能访问

总结:

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

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

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