面向对象编程 ---- 封装

封装

　　什么是封装

　　　　封装就是将复杂丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口.

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

为什么需要封装

　　两个目的

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

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

什么时候应该封装

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

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

如何使用:

class Person:
    def __init__(self,name,ID)
        self.name = name
        self.__ID = ID

p = Person('yzy','1122334455')

#在不想被外界修改的数据前面加上__

被封装的内容的特点:

　　1.外界不能直接访问

　　2.内部依然可以使用

权限

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

在python中只有两种权限:
　　1.公开的,默认就是公开的

　　2.私有的,只能由当前类自己使用

在外界访问私有内容

属性虽然被封装了,但是还是需要使用的,在外界如何访问?

　　通过定义方法类完成对私有属性的修改和访问

class Download:
    def __init__(self,filename,url,buffer_size)
        self.filename = filename
        self.url = url
        self.__buffer_size = buffer_size

    
    def start(self):
        if self.buffer_size <= 1024*1024:
            print('开始下载...')
            print('当前缓冲区的大小',self.buffer_size)
        else:
            print('内存炸了')
    
    def set_buffer_size(self,size):
        if type(size) == int:
            self.buffer_size = int
        else:
            print('请输入整型')
    
    def get_buffer_size(self):
        return self.buffer_size

d = Download('奥特曼','www.baidu.com',1024*1024)
 
d.start()
#通过函数去修改内部封装的属性
d.set.buffer_size(1024*520)

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

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

property

通过方法来修改或访问属性,本身没什么问题,但是这给对象的使用者带来了麻烦.

使用必须知道哪些是普通属性,哪些是私有属性,需要使用不同的方式来调用他们

property

有三个相关的装饰器

@property  #该装饰器用在获取属性的方法上
@key.setter  #该装饰器用在修改属性的方法上
@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
            print('修改成功')
        else:
            print('修改失败')

    @key.deleter
    def key(self)
        del self.__key
        print('删除成功')

a = A('yyy',123)
print(a.key)
a.key = 90
print(a.key)

del a.key

python实现封装的原理

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

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

封装总结:
对外部隐藏内部的实现细节,并提供访问接口

好处:

　　1.安全性提高

　　2.隔离复杂度

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

访问被隐藏的属性:

　　提供用于访问和修改的方法

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

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

property 可以用来实现计算属性

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

例如:求正方形的面积

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

    @property
    def area(self):
        return self.width * self.width

a = Square(10)

print(a.area())

接口

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

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

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

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

案例

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)

在上述案例中,pc的代码一旦完成,后期无论什么样的设备,只要遵循了USB接口协议,都能够被电脑所能调用,接口主要是方便了对象的使用者,降低了使用者的学习难度,只要学习一套使用方法,就可以以不变应万变

问题:

　　如果子类没有按照你的协议来设计,也没办法限制他,将导致代码无法运行

抽象类

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

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

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

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

然而,python不推崇限制你的语法, 我们可以设计成鸭子类型,既让多个不同类对象具备相同的属性和方法.对于使用者而言,就可以以不变应万变,轻松的使用各种对象

abc模块的使用

abc是abstract class的缩写   翻译成抽象类

抽象类的定义:类中包含  没有函数体的方法

import abc
class AClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass
    
 class B(AClass):
    
    def run(self):
        print('runrunrun')

b = B()