面向对象---封装

一、什么是封装？

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

　　

　　1、好处/目的

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

　　　　对外部隐藏实现细节,隔离复杂度

　　2、封装原因

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

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

　　语法 __+名字

class Person:
    def __init__(self,id_number,name,age)
        self.__id_number = id_number
        self.name = name
        self.age = age
   
p = Person("1111111111111","jack",29)

p.id_number = "222"

　　特点：

　　　　外界不能直接访问

　　　　内部依然可以使用

　　在外界访问私有内容是，可以通过定义方法类对完成私有属性的修改和访问

"""
这是一个下载器类,需要提供一个缓存大小这样的属性
缓存大小不能超过内存限制

"""
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.__buffer_size

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


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

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

d.start_download()

　　　　这样一来我们可以在外界修改这个关键数据时,做一些限制

　　封装的原理：

　　　　就是在加载类的时候,把__替换成了 _类名__

　　　　python一般不会强制要求程序必须怎么怎么的,

 

二、访问私有属性的方法

　　property装饰器

　　　　使用property装饰器可以将一个方法伪装成普通顺属性,报纸属性之间调用方法一致

　　　　封装的实现原理 ,替换变量名称

　　

　　property装饰就是为了使得调用方式一致

　　　　1.@property 该装器用在获取属性的方法上

　　　　2.@key.setter 该装器用在修改属性的方法上

　　　　3.@key.deleter 该装器用在删除属性的方法上

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


注意:key是被property装饰的方法的名称 也就是属性的名称 
内部会创建一个对象 变量名称就是函数名称  
所以在使用setter和deleter时 必须保证使用对象的名称取调用方法 
所以是 key.setter
'''
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)

　　

　　计算属性

　　　　property 可以用来实现计算属性

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

四、封装接口

　　接口目的就是为了提高扩展性

　　例如电脑提前指定制定一套USB接口协议,只要你遵循该协议,你的设备就可以被电脑使用,不需要关心到底是鼠标还是键盘

class USB:
    def open(self):
        pass

    def close(self):
        pass

    def  read(self):
        pass

    def write(self):
        pass

class Mouse(USB):
    def open(self):
        print("鼠标开机.....")

    def close(self):
        print("鼠标关机了...")

    def read(self):
        print("获取了光标位置....")

    def write(self):
        print("鼠标不支持写入....")


def pc(usb_device):
    usb_device.open()
    usb_device.read()
    usb_device.write()
    usb_device.close()

m = Mouse()
# 将鼠标传给电脑
pc(m)

class KeyBoard(USB):
    def open(self):
        print("键盘开机.....")

    def close(self):
        print("键盘关机了...")

    def read(self):
        print("获取了按键字符....")

    def write(self):
        print("可以写入灯光颜色....")

# 来了一个键盘对象
k = KeyBoard()
pc(k)

五、抽象类

　　指的是包含抽象方法(没有函数体的方法)的类,

　　作用:可以限制子类调用类中定义的抽象方法

　　

　　鸭子类型

　　　　如果这个对象长得像鸭子,走路像鸭子,那就他是鸭子　　

　　

　　接口是一套协议规范,明确子类们应该具备哪些功能

　　　　抽象类是用于强制要求子类必须按照协议中规定的来实现

　　　　然而,python不推崇限制你的语法, 我们可以设计成鸭子类型,既让多个不同类对象具备相同的属性和方法

　　　　对于使用者而言,就可以以不变应万变,轻松的使用各种对象