python3_类的封装概念理解

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2018/5/19 0:23
# @Author  : chenlin
# @File    : 封装之如何实现属性的隐藏.py

# 如何实现隐藏

"""
类的变量隐藏其实只是变了一个名字而已，并不是真的无法访问
不会执行代码，但会检查语法，同时将隐藏变量名修改
"""
# class A:
#     __x = 1  # _A__x=1
#
#     def __init__(self, name):
#         self.__name = name  # self._A__name=name ，不能真正的限制访问
#
#     def __foo(self):  # def _A__foo(self):
#         print('run foo')
#
#     def bar(self):
#         self.__foo()  # 在内部访问时，定义阶段就改变了名称self._A__foo()
#         print('from bar')

#### 查看类里的变量方法

# print(A.__dict__)  # 打印出类变量的名称
# print(A.__x)  # 报错，不存在，不存在此变量名
# print(A.__foo)  # 报错，不存在，不存在此变量名

# 只有下面的才是正确的

# a = A('egon')
# a._A__foo()
# print(a._A__x)

# print(a.__name)  # 报错，应该是a.__dict__['_A__name']
# print(a.__dict__)

# a.bar()

# 继承时，不存在覆盖隐藏变量这个方法

"""
要是真的将func修改为
class Foo:
    def __func(self):  # _Foo__func
        print('from foo')


class Bar(Foo):
    def __func(self):  # _Bar__func
        print('from bar')

此时在定义阶段。他们都是不一样的变量名，所以不存在覆盖这个说法
"""

#### 举例验证

# class B:
#     __x=1
#
#     def __init__(self,name):
#         self.__name=name #self._B__name=name


# 验证问题一：(在类外部访问，改变了变量名)
# print(B._B__x)


# 验证问题二：(变形只在定义是起作用，只有一次，定义后就不再重命名了)
# B.__y=2
# print(B.__dict__)
# b=B('egon')
# print(b.__dict__)
#
# b.__age=18
# print(b.__dict__)
# print(b.__age)


# 验证问题三：(在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的,因为名字变了)
# class A:
#     def foo(self):
#         print('A.foo')
#
#     def bar(self):
#         print('A.bar')
#         self.foo() #b.foo()
#
# class B(A):
#     def foo(self):
#         print('B.foo')
#
# b=B()
# b.bar()


# class A:
#     def __foo(self): #_A__foo
#         print('A.foo')
#
#     def bar(self):
#         print('A.bar')
#         self.__foo() #self._A__foo()
#
# class B(A):
#     def __foo(self): #_B__foo
#         print('B.foo')
#
# b=B()
# b.bar()



#### 小结
'''
封装的特点
这种变形的特点：
    1、在类外部无法直接obj.__AttrName
    2、在类内部是可以直接使用：obj.__AttrName
    3、子类无法覆盖父类__开头的属性(因为隐藏的属性名被添加了类名_Class__AttrName)
'''