面向对象--封装 多态

封装 字面意思 把什么东西装到容器在封闭起来
     与隐藏有相似意思 不是单纯的隐藏
    官方解释:对外部隐藏实现细节,并提供简单的使用接口

封装的好处
1.提高安全性
2.隔离复杂度

python 中属性访问权限
1.公开的(默认)在任何地方都能访问到
2.私有的 仅在类内部可以使用

如何封装:使用特殊语法:给要隐藏的变量名称前面加上两个下划线__
外部无法访问私有的内容


封装方法
场景 一些方法的存在是为了 完成其他的功能 这些方法就不应该提供给外界 例如发动机中的打火这个功能
当一个方法中的代码 太多时  我们需要将其拆分为不同的小函数 这个小函数不应该提供给外界

# class Person:
#     def __init__(self,name,sex,age,id_card):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         self.__id_card=id_card
#
#     def say_hi(self):
#         print('name is%s age is%s id is%s'%(self.name,self.age,self.__id_card))
#
#
# p1=Person('xxx','man',20,'xxxxxxxxx')
# p1.say_hi()
# # print(p1.__id_card)  外部无法访问

# class PC:
#     def boot(self):
#         self.__read_rom()
#         self.__boot_bios()
#         self.__read_opt()
#         self.__boot_gui()
#         print('电脑启动成功!')
#
#
#     def __read_rom(self):
#         print('读取rom中数据')
#     def __boot_bios(self):
#         print('启动BIOS系统')
#     def __read_opt(self):
#         print('读取并执行操作系统命令')
#     def __boot_gui(self):
#         print('启动用户界面')

# p1=PC()
# p1.boot()
# p1.__boot_gui()

访问器与设置器
    私有属性 外界无法完全使用 那就没有意义
    我们可以定义访问方法和设置方法
1.提供对私有属性的访问修改
2.增加额外的判断逻辑

    问题 :访问和修改私有属性的写法与普通属性的写法不一致
    对于使用而言更复杂了
使用property装饰器 可以将一个方法伪装成一个普通属性 这样对于使用者而言 使用方式就一致了
property 弊端是不能增加额外的参数 只能有一个参数self
访问器
@property   用点来访问你属性时触发
设置器
@属性名称.setter  用点来设置属性时触发 p1.id_card='123'
限制删除器
@属性名称.deleter  用del删除属性时触发 del.p1.id_card

python是通过变形的方式 拉完成私有化操作
具体:把双下划线开头的名字 在名字前添加一个_类名
发生变形操作是在定义阶段就发生了 并且只发生了一次
默认情况下 子类无论是类的内部还是外部都是不能访问父类的私有属性的  但是可以强行访问

# class Person:
#     def __init__(self,name,sex,age,id_card):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         self.__id_card=id_card
#
#     def say_hi(self):
#         print('name is%s age is%s id is%s'%(self.name,self.age,self.__id_card))
#
# #访问器
#     def get_id_card(self,pwd):
#         if pwd=='123321':
#             return self.__id_card
#         else:
#             print('没有访问权限!')
#
# #设置器
#     def set_id_card(self,new_id):
#         if len(new_id)==17or len(new_id)==18:
#             self.__id_card=new_id
#         else:
#             print('身份证格式错误!')
#
# p1=Person('xxx','man',29,'11111112223546987')
# # print(p1.get_id_card('123321'))
#
# p1.set_id_card('14785236996325874')
# print(p1.get_id_card('123321'))

# class Person:
#     def __init__(self,name,id_card):
#         self.name=name
#         self.__id_card=id_card
#
#     @property
#     def id_card(self):
#         return self.__id_card
#
#     @id_card.setter
#     def id_card(self,new_id):
#         self.__id_card=new_id
#
#     @id_card.deleter
#     def id_card(self):
#         print('你即将删除身份证了')
#         self.__dict__.pop('_Person__id_card')
#
# p1 =Person('xxx','123123')
# print(p1.__dict__)
# p1.id_card=1111111
# # del p1.id_card
# print(p1.__dict__)

interface 接口
一组功能集合体
好处:用于提高程序的扩展性
接口用于定义一组功能,后续的程序只要按照接口来实现 就能被使用
可以将接口理解为一套规范

抽象类
使用class来模拟接口的问题是 不能强行限制子类必须实现接口的方法
抽象在这里指的是 不具体 不清晰 看不懂

如果一个方法没有实现体 那么这个方法就可以称之为抽象方法
如果一个类中存在抽象方法 那么这个类也是抽象的

抽象类也是用于提高扩展性的 与接口相似的是也可以作为一套规范
比接口强大的地方在于 可以强行限制子类必须实现父类中声明的方法
抽象类无法直接实例化 只能由子类继承之后覆盖所有的抽象方法 才能实例化

import abc
# abstructclass
class Computer(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def boot(self):
        pass

    @abc.abstractmethod
    def close(self):
        pass
    #
    @abc.abstractmethod
    def working(self):
        pass

class NoteBook(Computer):

    def boot(self):
        print("笔记本开机啦")

    def close(self):
        print("笔记本关机啦")

    def working(self):
        print("笔记本正在计算")

n1 = NoteBook()
n1.boot()
n1.working()
n1.close()