面向对象—封装

# 广义上的封装 :把变量和函数都放在类中
# 狭义上的封装 :把一些变量 或者 方法 隐藏起来，不对外公开
    # 公有的 :
    # 私有的 : __名字

#Part1 私有静态属性
class FOO:
    name='alex'#普通的静态属性
    __pas='alex3714'#私有的静态属性
    # 类里的属性在加载阶段就已经执行了，除了函数内的代码，这行是可以正常打印
    print(name,__pas)#私有的名字，可以在类的内部调用
print(FOO.name)#name存在与类的内存中，所以可以直接通过类名访问
# #私有的名字，只能在类的内部使用，不能再类外部使用
# # print(FOO.__pas)##执行报错，type object 'FOO' has no attribute '__pas'
print(FOO._FOO__pas)#如果非要调用，可以这样访问：_类名__私有的名字（理论上这是不允许的）
FOO.__pas='hello'#会重新定义一个'__pas'不能改变私有的变量'_FOO__pas'
print(FOO.__dict__)#


#Part2 私有的对象属性，在类的方法中可以直接调用
class FOO:
    def __init__(self,name,pwd):
        self.name=name
        self.__pwd=pwd #私有的对象属性
    def login(self):
        if self.name=='alex'and self.__pwd=='alex3714':
            print('登陆成功')
person=FOO('alex','alex3714')
person.login()
print(person.__dict__)  #{'name': 'alex', '_FOO__pwd': 'alex3714'}


#part3 私有的方法
class Person:
    def __init__(self):pass
    def __eat(self):
        print('eating')
alex=Person()
alex.__eat() #实例不能访问该私有方法：'Person' object has no attribute '__eat'
# alex3714--》加密--》加密后的
#这个功能只想提供类内使用，不想外部用，就可以使用私有方法
#例如：制造密码
class Person:
    def __init__(self):pass
    def __制造密码转换(self,inp):
        print('转换%s'%inp)
    def 注册(self):
        inp = input('pwd>>>')
        加密之后的密码 = self.__制造密码转换(inp) #私有的方法，可以在类内被调用
alex=Person()
alex.注册()


#part4  面试题
class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    def func(self):
        print('in son')

s = Son()
#输出：in son

class Foo:
    def __init__(self):
        self.__func()  ##根据私有方法位置决定了__func()等同_Foo__func()
    def __func(self):
        print('in Foo')

class Son(Foo):
    def __func(self):##__func()等同_Son__func()
        print('in son')
s = Son()

#输出：in Foo