OOP >>> 封装

封装：

　　隐藏对象的属性和实现细节，仅对外提供公共访问属性

　　原则：

　　　　1. 将不需要对外提供的内容都隐藏起来；

　　　　2. 把属性都隐藏，提供公共方法对其访问（接口）

　　好处：

　　　　1. 将变化隔离； 

　　　　2. 便于使用；

　　　　3. 提高复用性； 

　　　　4. 提高安全性；

封装原理：就是在加载类的时候，把_ _属性  替换成了  _类名_ _属性

封装可以分为：对象的变量封装 >>> 私有变量          语法：在python中用 双下划线开头 的方式将属性隐藏起来（设置成私有的）

　　　　　　   对象的方法封装 >>> 私有方法           语法：在python中用 双下划线开头 的方式将属性隐藏起来（设置成私有的）

私有变量：

class Person:
    def __init__(self, id_number, name, age):
        self.__id_number = id_number  # 将身份证号码封装为私有属性/变量
        self.name = name
        self.age = age

    def show_id(self):
        print(self.__id_number)

p = Person("1111111111111", "jack", 29)

p.__id_number = "222"  # 这里只是增加了一个p的属性，不是重新赋值
print(p.__id_number)  # 222  访问的是p的__id_number属性

p.show_id()  # 1111111111111  # 原始的id_number并没有被改

print(p._Person__id_number)  # 1111111111111  此方式可以访问到原始值

# 变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

# 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
# p._Person__id_number是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
# 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的

私有方法：

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_services()
        print("启动GUI")
        self.__login()


    def __check_device(self):  # 定义为私有方法
        print("硬件检测1")
        print("硬件检测2")
        print("硬件检测3")
        print("硬件检测4")

    def __start_services(self):  # 定义为私有方法
        print("启动服务1")
        print("启动服务2")
        print("启动服务3")
        print("启动服务4")

    def  __login(self):  # 定义为私有方法
        print("login....")
        print("login....")
        print("login....")

pc1 = PC(20000,"香蕉","黄色")
pc1.open()  # 执行函数open（），同时执行函数内部的其他隐藏函数
pc1.login()  # AttributeError: 'PC' object has no attribute 'login' 没有此函数
pc1._PC__login()  # 直接访问到__login函数

# 定义为私有方法后，只能从类的内部访问到，外界不能直接访问

 PS：在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

如何访问被封装的属性？？？？

　　前面其实已经可以看出，我们可以通过类内部的函数方法来访问，甚至可以对被封装后的属性进行修改。如下：

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

"""
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.start_download()  # 开始下载....  当前缓冲器大小 1048576


# 通过函数取修改内部封装的属性d.set_buffer_size(1024*512)  # 缓冲区大小修改成功!# 通过函数访问内部封装的属性print(d.get_buffer_size())  # 524288print(d.filename)  # 葫芦娃

Property装饰器：

　　虽然我们可以通过类内部函数来访问隐藏的私有属性，但是对于不知状况的用户来讲就有点麻烦了，使用必须知道哪些是普通属性，哪些是私有属性，需要使用不同的方式来调用他们  。所以我们需要对这些函数进行一些装饰，让其可以直接像公开属性一样直接被访问，但是还是对其修改上做了一定的限制，限制其职能被修改为特定的形式。

　　property装饰就是为了使得调用方式一致（使用property装饰器可以将一个方法伪装成普通属性，保证属性之间调用方法一致）

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

　　@隐藏属性名.setter       该装饰器用在修改属性的方法上

　　@隐藏属性名.deleter     该装饰器用在删除属性的方法上

class A:
    def __init__(self,name,key):
        self.name = name
        self.__key = key  # 定义为私有属性

    @property  # 装饰器  可以实现get，set，delete三种方法  #只有在属性key定义property后才能定义key.setter,key.deleter
    def key(self):
        return self.__key  # get私有属性值

    @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)  # 123  可以间接访问到，但是用户并不知道中间执行了函数，还以为是直接跟访问name一样直接访问的

a.key = 321  # key 必须小于等于100 >>> 修改过程

print(a.key)  # 123    由于修改时候条件不成立，所以返回的还是原值。若是公开属性，那么这一步骤就直接执行，key直接被修改

del a.key  # 不允许删除该属性  私有属性不会像公开属性一样直接就可以被删除

 　　此外，Property 还具有计算属性（属性的值不能直接获得，必须通过计算才能获取 ），可应用于下面的场景：

# 练习: 定义一个类叫做person
# 包含三个属性 身高 体重   BMI
# BMI的值需要通过计算得来 公式   体重 / 身高的平方


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  可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值

s.width = 20

print(s.area)  # 400

s.width = 2
print(s.area)  # 4

 ################################

补充：一个静态属性property本质就是实现了get，set，delete三种方法：如下：

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

# 上面的三个函数就相当于类内部的一个变量，变量AAA = 一个值

f1=Foo()  # 实例化过程
f1.AAA  # 查看公开属性
f1.AAA='aaa'  # 对属性进行修改操作
del f1.AAA  # 对属性进行删除操作

 ################################

 接口：

　　接口是一组功能的集合，但是接口中仅包含功能的名字，不包含具体的实现代码

　　接口本质是一套协议标准，遵循这个标准的对象就能被调用

　　目的：提高扩展性

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

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

　　如何强制？？？如下：

import abc


class USB(metaclass=abc.ABCMeta):

    @abc.abstractmethod  # 用来限制子类，假如子类没有此方法，具不能正常使用
    def run(self):
        print('你好啊')

    @abc.abstractmethod
    def close(self):
        pass

    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass


class Mouse(USB):

    def run(self):
        print('1')

    def close(self):
        print('2')

    def read(self):
        print('3')

    def write(self):
        print('4')


class KeyBoard(USB):
    
    pass

k = KeyBoard()  # 由于KeyBoard这个USB的子类内部没有相应的功能代码，导致不能使用的情况
k.close()  # TypeError: Can't instantiate abstract class KeyBoard with abstract methods close, read, run, write


m = Mouse()  # Mouse类内部具有跟USB一样的功能，所以代码能正常使用
m.run()  # 1