面向对象之封装

封装 

​ 　　封装就是把一堆东西放在一个容器内部，对外隐藏内部实现细节,并提供访问的接口。例如电脑，内部的主板硬盘，CPU，线路都被电脑外壳封装在一个壳子内，外部只提供有电源接口，usb接口，或者耳机接口。这就是一种封装。

　　封装的目的有两个，1个是为了保证安全性，对外隐藏，实现细节，和复杂度的隔离。

　　python中的类就是一个容器。可以把各种函数属性和数据属性放入其中。有些数据我们不想让外界直接访问到或更改类中的一些关键数据，这个时候就可以使用封装。

  　封装的使用语法是在属性名称前加双下划线。在类内定义的属性前加__开头(没有__结果)。__开头的属性实现的隐藏仅仅只是一种语法意义上的变形,并不会真的限制类外部的访问：该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形：如果父类不想让子类覆盖自己的属性,可以在属性前加__开头。封装数据属性:将数据属性隐藏起来,类外就无法直接操作属性,需要类内开辟一个接口来外部的使用可以间接地操作属性。从而严格控制使用对属性的操作。

class A:
    def __init__(self, a):
        self.__a = a     #属性a被封装。

    def __run(self):     # 函数属性run被封装
        print('aaaa')
    # pass
b = A(1)

　　 被封装的内容的特点：外界不能直接访问但是内部依然可以使用。封装之后就可以明显控制属性的权限。在python只有两种权限,一种是公开的.默认就是公开的，一种是私有的,只能由当前类自己使用 。在外界访问私有的内容

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

# 模拟封装在下载中的应用
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()

property装饰器

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

有三个相关的装饰器 

　　1.property   该装器用在获取属性的方法上 但是只能装饰单个值
　　2.@key.setter  该装器用在修改属性的方法上 ，修改函数的形参除了自身(self）还需要放一个形参。
　　3.@key.deleter 该装器用在删除属性的方法上 ，

　　注意:key是被property装饰的方法的名称 也就是属性的名称 ，内部会创建一个对象 变量名称就是函数名称 

所以在使用setter和deleter时 必须保证使用对象的名称取调用方法 。

class Preson:
    def __init__(self, msg, text):
        self.__mak1 = msg
        self.text = text
    @property
    def mak1(self):          # 伪装成普通属性
        return self.__mak1
    @mak1.setter
    def mak1(self, new_mak1):   # 传参新值new_mak1
        self.__mak1 = new_mak1
        return self.__mak1
    @mak1.deleter
    def mak1(self):
        del self.__mak1
p = Preson([1,2,3], ['a', 'b'])
print(p.mak1)
p.mak1 = 1
print(p.mak1)
del p.mak1
print(p.mak1)

　　 python实现封装的原理

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

 

 

　　 property 可以用来实现计算属性.计算属性指的是:属性的值,不能直接获得,必须通过计算才能获取 

　　例如:正方形求面积

class S:
    @property
    def side(self):
        return self.__side * self.__side
    @side.setter
    def side(self, new_side):
        self.__side = new_side

d = S()
d.side = 4
print(d.side)

　　接口是一组功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码 .这些功能定义一套标准。接口本质是一套协议标准,遵循这个标准的对象就能被调用 。

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

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

案例

classUSB:defopen(self):passdefclose(self):passdefread(self):passdefwrite(self):passclassMouse(USB):defopen(self):print("鼠标开机.....")defclose(self):print("鼠标关机了...")defread(self):print("获取了光标位置....")defwrite(self):print("鼠标不支持写入....")defpc(usb_device):usb_device.open()usb_device.read()usb_device.write()usb_device.close()m=Mouse()#将鼠标传给电脑pc(m)classKeyBoard(USB):defopen(self):print("键盘开机.....")defclose(self):print("键盘关机了...")defread(self):print("获取了按键字符....")defwrite(self):print("可以写入灯光颜色....")#来了一个键盘对象k=KeyBoard()pc(k)

　　在上述案例中,PC的代码一旦完成,后期无论什么样的设备 只要遵循了USB接口协议,都能够被电脑所调用 。接口主要是方便了对象的使用者,降低使用者的 学习难度,只要学习一套使用方法,就可以以不变应万变。如果子类没有按照你的协议来设计,也没办法限制他,将导致代码无法运行。有了一套标准，按这个标志做，兼容性将会更强。

　　 在规则指定中有一种类叫抽象类，指的是包含抽象方法(没有函数体的方法)的类,。它作用:可以限制子类必须类中定义的抽象方法 。

import abc
# absttract class
class A(metaclass=abc.ABCMeta):     # 抽象类
    @abc.abstractmethod    # 子类重新写被装饰的函数
    def run(self):
        print('asdada')
class B(A):
    def run(self):        # 在子类B中必须要写一个run函数
        print('aaaa')
b = B()

　　最后:python一般不会限制你必须怎么写,作为一个优秀的程序员,就应该自觉遵守相关协议，为了将来的扩展性以及与同属的合作。这种方式大家称之为鸭子类型。保持队形，和格式的一致性。要保证你的类按照相关的协议类编写,也可以达到提高扩展性的目的  。

class Mouse:
    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:
    def open(self):
        print("键盘开机.....")
    def close(self):
        print("键盘关机了...")
        
    def read(self):
        print("获取了按键字符....")
        
    def write(self):
        print("可以写入灯光颜色....")
        
# 来了一个键盘对象
k = KeyBoard()
pc(k)
class UDisk:
    def open(self):
        print("U盘启动了...")
    def close(self):
        print("U盘关闭了...")
    def read(self):
        print("读出数据")
    def write(self):
        print("写入数据")
u = UDisk()
pc(u)

　　接口是一套协议规范,明确子类们应该具备，抽象类是用于强制要求子类必须按照协议中规定的来实现 。然而,python不推崇限制你的语法, 我们可以设计成鸭子类型,既让多个不同类对象具备相同的属性和方法，。对于使用者而言,就可以以不变应万变,轻松的使用各种对象