代码改变世界

面向对象之封装

2019-11-09 22:49  风e逸  阅读(74)  评论(0)    收藏  举报 
封装的意义是隐藏
a. 单线划线  _  ,这是一种声明，默认规则为：此函数为内部函数，外部不应该调用。但是此方法没有什么限制力，只是一种说明。外部想要调用，还是可以调用的。
 1 class People:
 2     _dir = '这是一个人'
 3     def __init__(self, name, age, sex):
 4         self.name = name
 5         self.age = age
 6         self.sex = sex
 7 
 8 
 9 P1 = People('alex', 18, 'man')
10 # print(P1.age)
11 print(P1._dir) # 返回结果为：这是一个人, _dir 可以被调用
b.双下划线 __
      双下划线一定程度上实现了外部无法调用，或者说，无法直接调用，直接调用时会报错，但是可以通过 _类名__   的方法来调用
 1 class People:
 2     __dir = '这是一个人'
 3     def __init__(self, name, age, sex):
 4         self.name = name
 5         self.age = age
 6         self.sex = sex
 7 
 8 
 9 P1 = People('alex', 18, 'man')
10 # print(P1.age)
11 # print(P1.__dir) # 如此方法调用会报错
12 print(P1._People__dir) # 返回结果为:这是一个人, __dir 可以被调用

真正的封装，并不仅仅是封起来，而且给转接一个访问函数，可以通过访问函数来调用想要获得的值，而非直接调用。
class People:
    __dir = '这是一个人'
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 访问函数/接口函数
    def get_dir(self):
        print(self.__dir)

P1 = People('alex', 18, 'man')

P1.get_dir()

输出结果：这是一个人



　此外，封装起来的函数，在外部导入调用时，用from 文件 import * 是不能直接导入的，需要具体导入函数名才能导入使用。　



当然，下划线的作用不仅于此，双下划线更多的作用是：


　　　　避免父类方法被子类方法覆盖的




 1 class A(object):
 2 
 3     def __method(self):
 4         print("I'm a method in class A")
 5 
 6     def method_x(self):
 7         print("I'm another method in class A\n")
 8 
 9     def method(self):
10         self.__method()
11         self.method_x()
12 
13 
14 class B(A):
15 
16     def __method(self):
17         print("I'm a method in class B")
18 
19     def method_x(self):
20         print("I'm another method in class B\n")
21 
22 
23 if __name__ == '__main__':
24     
25     a = A()
26     a.method()
27 
28     b = B()
29     b.method()
30 
31 
32 返回结果：
33 34 I'm a method in class A
35 I'm another method in class A
36 
37 I'm a method in class A   # 此位置没有被覆盖
38 I'm another method in class B




  由此可见，子类想通过继承之后进行修改 双下划线函数 '__XX'  是不可行的