12.6 类的封装

目录

• 12.6 类的封装
  • 1. 封装的两个层面
  • 2. 封装的好处
  • 3.获取封装的属性或方法（了解）

12.6 类的封装

• 封装是什么?打包，封起来，装起来。封装是针对类的，
• 封装分为两个层面:
  • 第一个层面：对象能拿到类的东西，但是类不能拿到对象的东西。
  • 第二个层面：内部可以使用，外部不可以使用、在需要封装的属性前面加上__。

1. 封装的两个层面

第一个层面：对象能拿到类的东西，但是类不能拿到对象的东西。

class Foo():
    count=0

f=Foo()
print(f.count) #对象能拿到类属性
#输出：0

f.name='coco'
# print(Foo.name) #类拿不到对象的属性

第二个层面：内部可以使用，外部不可以使用、在需要封装的属性前面加上__

class Foo():
    __count=0
    print('in',__count) #能找到__count
    #输出：in 0
    
print('out',Foo.__count) #找不到__count

2. 封装的好处

• 属性封装的好处：保护隐私，类内部的属性不想让其他人访问。
• 方法封装的好处：可以精简代码，使用方法就行，不需要方法的具体步骤；并且外部调用者也不知道内部发生了什么。

# 属性封装
class Foo():
    __count=0
    def __f1(self):
        pass
        
print('out',Foo.__f1)  #找不到

# 方法封装
class People():
    def __nawan(self):
        print('nawan')
    def __chifan(self):
        print('chifan1')
    def chifan_all(self):
        self.__nawan()
        self.__chifan()

peo=People()
print('out',peo.chifan_all())
#输出
nawan
chifan1
out None

#内部是类体代码，外部是类外面

3.获取封装的属性或方法（了解）

class People:
    def __init__(self,name):
        self.__name=name #封装后只有内部能拿到
    def get_name(self):
        return f'名字为{self.__name}'
p=People('coco')
print(p.get_name())

#输出：名字为coco

#应用
class People:
    def __init__(self,pwd):
        self.__pwd=pwd 
        
    @property #方法可以不用加括号使用
    def pwd(self):
        return f'无法获取你的密码'
        
p=People('123')
print(p.pwd )
#输出：无法获取你的密码

class F1:
    __count=0

f=F1()
print(f._F1__count) #'_类名__属性'可以拿到封装的属性，可以拿到，但是不建议这样做

#输出：0

class Foo():
    __count=0

foo=Foo() 
print(foo._Foo__count)
#输出：0

foo.__y=1 #外部
print(foo.__y)#外部可以访问

#输出：1