面向对象三大特性之——封装

一、什么是封装

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

二、为什么需要封装

两个目的：1.为了保证 关键数据的安全性   2.对外部隐藏实现细节，隔离复杂度

三、什么时候应该封装

当有一些数据不希望外界可以直接修改时，或者当有一些函数不希望给外界使用时

使用语法：将要封装的属性或者方法名称前加上双下划线

class Per:
    def __init__(self,id_num,age,name):
        self.__id_num = id_num
        self.age = age
        self.name = name
    def show(self):
        print(self.__id_num)

p = Per('11111',19,'jack')
p.__id_num  = '333'    #我们在这里改__id_num的值
p.show()   #'11111'    #在这里查询实际上__id_num没有修改，这个就是封装了，外部访问不到

四、在外界访问私有的内容（就是被封装的内容）

属性虽然被封装了，但是还是需要使用的，在外界如何访问，这里有一种简单的方法，通过在类内部定义一个函数来完成对私有属性的修改和访问，我们在外界修改这个关键数据时，还可以做一些条件限制。

class Per:
    def __init__(self,id_num,age,name):
        self.__id_num = id_num
        self.age = age
        self.name = name
    def show(self):
        print(self.__id_num)

    def set_id_num(self,num):  #定义一个修改私有属性的函数
        self.__id_num = num
        return self.__id_num

p = Per('11111',19,'jack')
p.set_id_num('44444')   #调用set_id_num方法把id_num值改掉
p.show()      #'44444'

总结一下被封装的内容的特点：

1、外界不能直接访问

2、内部任然可以使用

权限：学习了封装后就可以控制属性的权限

在python只有两种权限：

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

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

五、通过装饰器来修改属性 ******

前面我们通过定义方法来修改或访问属性，本身没什么问题，但是这给对象的使用者带来了麻烦。使用者必须知道哪些是普通属性，哪些是私有属性，需要使用不同的方式来调用他们。

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

有三个相关的装饰器

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

******
注意:在2，3装饰器中的key是被property装饰的方法的名称 也就是被封装的属性的名称 
内部会创建一个对象 变量名称就是函数名称  
所以在使用setter和deleter时 必须保证使用对象的名称取调用方法 
所以是 key.setter和  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)  #获取key的值    #123
a.key = 2     #修改key的值为2
print(a.key)   #2
del a.key    #删掉 key

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)   #100    #如果你不用@property用s.area()也可以获得同样效果

python实现封装的原理：

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

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

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

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

a = A("123")

print(a.key)   
print(a._A__key)  #内部已经把__key改成_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)

在上诉案例中，PC的代码一旦完成后，后期无论什么样的设备 只要遵循了USB接口协议，都能被电脑所调用。

接口主要是方便了对象的使用者，降低使用者的学习难度，只要学习一套使用方法，就可以以不变应万变。

七、抽象类

指的是包含抽象方法（没有函数体的方法）的类。作用：可以限制子类必须类中定义的抽象方法

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