面向对象（三）

一、封装

　　1.什么是封装

　　　　将复杂丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口

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

　　2.为什么需要封装

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

　　　　（2）对外部隐藏实现细节，隔离复杂度

　　3.什么时候应该封装

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

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

　　4.如何使用：

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('111', 'jack', 29)

p.__id_number = '222'
print(p.__id_number)
p.show_id()

　　5.封装方法

 

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()
# pc1.login()

　　6.被封装的内容的特点

　　　　（1）外界不能直接访问

　　　　（2）内部依然可以使用

二、权限

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

　　在python中只有两种

　　（1）公开的，默认是公开的

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

三、在外界访问私有的内容

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

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

"""
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())
print(d.filename)

d.start_download()

四、property装饰器

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

　　有三个相关的装饰器

　　（1）property　　该装饰器在获取属性的方法上

　　（2）@key.setter　　该装饰器用在修改属性的方法上

　　（3）@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
        else:
            print("key 必须小于等于100")

    @key.deleter
    def key(self):
        print("不允许删除该属性")
        del self.__key

a = A("jack",123)

print(a.key)
a.key = 321
print(a.key)
del a.key
print(a.key)

a.name = "xx"
print(a.name)

五、python实现封装的原理

　　1.加载类的时候，把__替换成了_类名__

　　　　ps:python一般不会强制要求程序必须怎么怎么的

　　2.封装

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

　　　　好处：

　　　　（1）提高安全性

　　　　（2）隔离复杂度

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

　　　　访问被隐藏的属性：

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

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

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

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._A__key)

a.__name = 1
print(a.__dict__)

六、property可以用来实现计算属性

　　1.计算属性指的是：属性的值，不能直接获得，必须通过计算才能获取

　　2.例如：正方形求面积

class Square:
    def __init__(self,width):
        self.width = width
        
    @property
    def area(self):
        return self.width * self.width
    
s = Square(10)
print(s.area)
s.width = 20
print(s.area)

　　3.练习

 

# 练习: 定义一个类叫做person
# 包含三个属性 身高 体重   BMI
# BMI的值需要通过计算得来 公式   体重 / 身高的平方
class Person:
    def __init__(self,height,weight):
        self.height = height
        self.weight = weight

    @property
    def BMI(self):
        return self.weight / (self.height**2)

p = Person(1.72,64)
print(p.BMI)

七、接口

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

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

　　3.接口目的是为了提高扩展性

　　4.练习

# 例如电脑提前指定制定一套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)

　　在上述案列中，pc的代码一旦完成，后期无论怎么样的设备，只要遵循了USB接口协议，都能够被电脑所调用

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

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

八、抽象类

　　1.包含抽象方法（没有函数体的方法）的类

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

　　3.作为优秀的程序员，就应该自觉遵守相关协议

　　　从而有了鸭子类型：这个对象长得像鸭子，走路像鸭子，那他就是鸭子类型

　　　只要保证类按照相关的协议类编写，也可以达到提高扩展性

　　4.例子

# 例如电脑提前指定制定一套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)

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

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

　　　　而python不限制语法，所以可以设计成鸭子类型，既让多个不同类对象具备相同的属性和方法

　　　　对于使用者而言，就可以以不变应万变，轻松的使用各种对象

　　ps：

　　abc模块的使用

　　　　abc（abstract class）抽象类

　　例子：两个类中的函数数量必须一致

import abc

class AClass(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def run(self):
        pass
    @abc.abstractmethod
    def run1(self):
        pass

class B(AClass):

    def run(self):
        print("runrunrurn...")

b = B()

转载于:https://www.cnblogs.com/yljbky/articles/11252168.html