面向对象之封装

一.什么是封装

　　封装就是将复杂的丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口

　　对外隐藏内部实现细节，并提供访问的接口

二.为什么需要封装

　　1.为了保证关键数据的安全性

　　2.对外部隐藏实现细节，隔离复杂度

三.什么时候应该封装

　　1.当有一些数据不希望外界可以直接修改时，

　　2.当有一些函数不希望给外界使用时

四.如何使用：

class Person:
    def __init__(self,id_number,name,age):
          self.__id_number = id_number
          self.name = name
          self.age = age
p = Person('32030219961011002500','jack',18)

这里的id_number这个属性就被封装了，外界不可调用和查询，只能在类内部使用

1.被封装的内容的特点

　　1.外界不能直接访问

　　2.内部依然可以使用

2.权限:

　　学习了封装后就可以控制属性的权限在Python只要两种权限：

　　　　1.公开的，默认就是公开的

　　　　2.私有的，只能由当前类自己使用

案例：封装类中的方法,为了隔离复杂度

class PC:

    def __init__(self,price,kind,color):
        self.price = price
        self.kind = kind
        self.color = color

    def open(self):
        print('接通电源')
        self.__check_device()
        print('载入内核')
        print('初始化内核')
        self.__start()
        print('启动GUI')
        self.__login()
    def __check_device(self):
        print("硬件检测")
        print("硬件检测")
        print("硬件检测")
        print("硬件检测")
        print("硬件检测")

    def __start(self):
        print('启动服务')
        print('启动服务')
        print('启动服务')
        print('启动服务')
        print('启动服务')

    def __login(self):
        print('login')
        print('login')
        print('login')
pc1 = PC(2000,'apple','blue')
pc1.open()

 

五.在外界访问私有的内容

属性虽然被封装了，但是还是需要使用，在外界如何访问，通过定义方法类完成对私有属性的修改和访问

案例：

class Downloader:
    def __init__(self,filename,url,buffer_size):
        self.filename = filename
        self.url = url
        self.__buffer_size = buffer_size
    
    def start_download(self):
        if self.__buffer_size <= 1024*1024：
            print('开始下载...')
            print('当前缓冲器大小：'self.__buffer_size)
        else:
            print('内存炸了！')
      
    def set_buffer_size(self,size):
        if not type(size) == int:
            print('大哥 缓冲器必须是整形')
        else:
            print('缓冲区大小修改成功！')
            self.__buffer_size = size
    
     def get_buffer_size(self):
            return self.__buffre_size

d = Downloader('葫芦娃','http://www.huluwa.com',1024*1024)

#通过调用函数修改内部封装的属性
d.set_buffer_size(1024*512)

#通过调用函数访问内部封装的属性
print(d.get_buffer_size())

d.start_download()              

六.property装饰器

通过方法来修改或访问属性，本身没什么问题，但是这样给对象的使用者带来了不方便，使用必须知道那些是普通属性，哪些是私有属性，需要使用不同的方式来调用他们，property装饰器就是为了使得调用方式一致

下面有三个相关的装饰器：

1.@property  用在获取属性的方法上
2.@key.setter  用在修改属性的方法上
3.@key.deleter 用在删除属性的方法上

案例：

class A:
    def __init__(self,name,key):
            self.__name__=name
            self.key = key

    @property
    def key(self):
        return self.__key

    @key.setter
    def key(self,new_key):
        if new_key <= 100:
            self.__key = new_key
        else:
            print('key必须小于等于100')
    
    @key.deleter
    def key(self):
        print("不允许删除该属性")
        del self.__key

a = A('jack',123)
print(a.key)
a.key = 321
print(a.key)

python实现封装的原理:

　　就是在加载类的时候，把__替换成了_类名__  例如将__name 替换成了 _A__name

　　封装就是对外部隐藏内部的实现细节，并提供访问的接口

　　好处：

　　　　1.提高安全性

　　　　2.隔离复杂度

　　访问被隐藏的属性：

　　　　提供用于访问和修改的方法

　　　　使用property装饰器可以将一个方法伪装成普通属性，属性之间的调用方法是一致的

property可以用来实现计算属性　

计算属性指的是:属性的值，不能直接获得，必须通过计算才能获取

案例：

class Square:
        def __init__(self,width):
            self.width = width
    
        @property
        def area(self):
            return self.width*self.width

s = Square(10)
print(s.area)
s.width = 20
print(s.area)
s.width =2
print(s.area)