面向对象三大特性之封装

什么是封装：

封装就是把复杂的细节的内容封装隐藏起来，提高了安全性和减少了复杂度

就是为了限制外界对内部细节的访问，但也不是完全的隐藏，会提供一个接口给外部用来

访问

为什么需要封装：

两个目的：

　　1.提高了程序的安全性

　　2.对外界隐藏了细节，隔离了复杂度

什么时候应该封装

当需要对外界隐藏重要的内容的时候

使用

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

被封装的内容的特点

被封装后的内容，在外部不能直接使用点语法获取了。

在内部依然可以使用

权限

在python中只有两种权限

1.公开的

2.私有的

依照开放封闭原则

在外界访问私有的内容

class Downloads:
    def __init__(self,name,url,buf_size):
        self.name = name
        self.url = url
        self.__buf_size = buf_size

    def start(self):
        if self.__buf_size <= 1024*1024:
            print('开始下载')
            print('缓冲区大小:',self.__buf_size)

    def set_size(self,size):
        if not type(size) == int:
            print('必须是整型')
        else:
            print('缓冲区大小修改成功')
            self.__buf_size = size

    def get_size(self):
        return self.__buf_size

d = Downloads('jack',11,2000)
print(d.name)
print(d.url)
d.start()
d.set_size(3000)
print(d.get_size())

property装饰器

前面我们虽然说封装了，但调用的时候却变换成了调用函数，原本是调用属性。

所以这个装饰器就是为了将一个方法伪装成一个属性，保持一致性

有三个相关的装饰器：

　　1.@property  用来获取属性的值

　　2@key.setter  用来修改属性的值

　　3@key.deleter 用来删除属性的值

例子：

class A:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    @property
    def key(self):
        return self.__age

    @key.setter
    def key(self,new_age):
        self.__age =new_age
        return self.__age

    @key.deleter
    def key(self):
        del self.__age


a = A('jack',18)
# print(a.key)

# a.key = 20
# print(a.key)
del a.key
print(a.key)

 

python实现封装的原理

python实现封装的原理就是在实行代码的过程中将__age转换成了_类名__

property 可以用来实现计算属性

可以实现正方形的面积大小

例子：

class Square:
    def __init__(self,width):
        self.width = width

    @property
    def size(self):
        return self.width * self.width
    @size.setter
    def size(self,new_size):
        self.width = new_size
        return self.width

s = Square(4)
s.size = 10
print(s.size)

接口

接口就是一套协议规范，一组功能的结合，但接口中包括功能的名字，并不包含功能具体的实现代码。遵循这套标准的对象就能够被调用。

目的就是为了提高扩展性

案例：

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)

抽象类

抽象类指的就是包含抽象方法（没有函数体的方法）的类

作用：可以限制子类必须按照类中定义的抽象方法，目的也是为了提高扩展性。

用到了abc模块

 

鸭子类型：

指的就是这个对象长的像鸭子，走路像鸭子，叫声像鸭子，那它没跑了就是鸭子。

目的也是为了扩展功能。

其就是用同一个方法得到不同的结果。

例子：

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)