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

【一】面向对象的三大特性

面向对象编程有三大特性：
- 封装、继承、多态
其中最重要的一个特性就是封装。
- 封装指的就是把数据与功能都整合到一起
听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。
除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口

【1】什么是封装

在程序设计中，封装（Encapsulation）是对具体对象的一种抽象
- 即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。
- 要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。

【2】为什么要封装

封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）

【3】封装的方法

电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

【二】隐藏属性

【1】隐藏属性方法

Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的）
但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成_类名__属性名的形式：

class Person:
     # 变形为_Person__NAME
    __NAME = "ZHANG"

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def __init__(self):
        # 变形为self._Person__age
        self.__age = 18
	# 变形为_Foo__run
    def __run(self):
        print('__f1 run')
	# 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def walk(self):
        self.__run()

print(Person.__N)
# 报错AttributeError:类Person没有属性__N
obj = Person()
print(obj.__x)
# 报错AttributeError:对象obj没有属性__x

【2】问题

（1）隐藏属性访问

在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：__类名__属性，然后就可以访问了，
如Person._Person__NAME，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。

class Person:
    # 变形为_Person__NAME
    __NAME = "Dream"

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def __init__(self):
        # 变形为self._Person__age
        self.__age = 18

    # 变形为_Person__run
    def __run(self):
        print('__f1 run')

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def walk(self):
        # 变形为self._Person__run()
        self.__run()


# 查看当前类的名称空间
print(Person.__dict__)
# {'__module__': '__main__', '_Person__NAME': 'Dream', '__init__': <function Person.__init__ at 0x000001C4059513F0>, '_Person__run': <function Person.__run at 0x000001C405951B40>, 'walk': <function Person.walk at 0x000001C405951BD0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__NAME
print(Person._Person__NAME)

# 实例化得到类对象
person = Person()
# Dream

# 查看对象的名称空间
print(person.__dict__)
# {'_Person__age': 18}

# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__age
print(person._Person__age)
# 18

（2）隐藏方法变形

在类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。

class Person:
    # 变形为_Person__NAME
    __NAME = "Dream"

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def __init__(self):
        # 变形为self._Person__age
        self.__age = 18

    # 变形为_Person__run
    def __run(self):
        print('__f1 run')

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def walk(self):
        # 变形为self._Person__run()
        self.__run()  # 等同于 self._Person__run()
        print(self.__NAME)  # 等同于 print(self._Person__age)

（3）变形操作只会发生一次

变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。

class Person:
    # 变形为_Person__NAME
    __NAME = "Dream"

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def __init__(self):
        # 变形为self._Person__age
        self.__age = 18

    # 变形为_Person__run
    def __run(self):
        print('__f1 run')

    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
    def walk(self):
        # 变形为self._Person__run()
        self.__run()  # 等同于 self._Person__run()
        print(self.__NAME)  # 等同于 print(self._Person__age)


# 修改类的变量
Person.__NAME = "Hope"

# 查看内存空间 --- 发现并没有被修改
print(Person.__dict__)
# {'__module__': '__main__', '_Person__NAME': 'Dream', '__init__': <function Person.__init__ at 0x00000260E28E13F0>, '_Person__run': <function Person.__run at 0x00000260E28E1B40>, 'walk': <function Person.walk at 0x00000260E28E1BD0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, '__NAME': 'Hope'}

# 实例化得到类对象
person = Person()
# Dream

# 修改对象变量
person.__sex = "男"
person.__age = 22

# 查看对象的名称空间 --- 新增了相应的键值
print(person.__dict__)
# {'_Person__age': 18, '__sex': '男', '__age': 22}

# 可以直接根据键取值
print(person.__sex)

【三】开放接口

定义属性就是为了使用，所以隐藏并不是目的

【1】隐藏数据属性

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
目的的是为了隔离复杂度
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
  - 比如插卡、身份认证、输入金额、打印小票、取钱等
- 而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来

class ATM:
    # 插卡
    def __card(self):
        print('插卡')

    # 身份认证
    def __auth(self):
        print('用户认证')

    # 输入金额
    def __input(self):
        print('输入取款金额')

    # 打印小票
    def __print_bill(self):
        print('打印账单')

    # 取钱
    def __take_money(self):
        print('取款')

    # 取款功能
    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()


obj = ATM()
obj.withdraw()
# 插卡
# 用户认证
# 输入取款金额
# 打印账单
# 取款

总结隐藏属性与开放接口，本质就是为了明确地区分内外，类内部可以修改封装内的东西而不影响外部调用者的代码；
而类外部只需拿到一个接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变代码。
这就提供一个良好的合作基础，只要接口这个基础约定不变，则代码的修改不足为虑。

【四】装饰器property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
面向对象的封装有三种方式:
- 【public】
  - 这种其实就是不封装,是对外公开的
- 【protected】
  - 这种封装方式对外不公开
  - 但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
- 【private】
  - 这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class Foo:
    def __init__(self, val):
        # 将属性隐藏起来
        self.__NAME = val

    @property
    def name(self):
        return self.__NAME

    @name.setter
    def name(self, value):
        # 在设定值之前进行类型检查
        if not isinstance(value, str):
            raise TypeError('%s must be str' % value)
        # 通过类型检查后,将值value存放到真实的位置self.__NAME
        self.__NAME = value

    @name.deleter
    def name(self):
        raise PermissionError('Can not delete')


f = Foo('dream')
print(f.name)

# 触发name.setter装饰器对应的函数name(f,'Hope')
f.name = 'Hope'  

# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
f.name = 123  

# 触发name.deleter对应的函数name(f),抛出异常PermissionError
del f.name 
class Foo:
    def __init__(self, val):
        # 将属性隐藏起来
        self.__NAME = val

    def get_name(self):
        return self.__NAME

    def set_name(self, value):
        # 在设定值之前进行类型检查
        if not isinstance(value, str):
            raise TypeError('%s must be str' % value)
        # 通过类型检查后,将值value存放到真实的位置self.__NAME
        self.__NAME = value

    def del_name(self):
        raise PermissionError('Can not delete')

    # 不使用装饰器，而是使用 包装的 形式
    name = property(get_name, set_name, del_name)


f = Foo('dream')
print(f.name)

# 触发name.setter装饰器对应的函数name(f,'Hope')
f.name = 'Hope'

# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
f.name = 123

# 触发name.deleter对应的函数name(f),抛出异常PermissionError
del f.name

【五】封装和扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；
而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。
这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

【1】设计者

class Room:
    def __init__(self, name, owner, width, length, high):
        self.name = name
        self.owner = owner
        self.__width = width
        self.__length = length
        self.__high = high

    # 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
    def tell_area(self):  
        return self.__width * self.__length

【2】使用者

class Room:
    def __init__(self, name, owner, width, length, high):
        self.name = name
        self.owner = owner
        self.__width = width
        self.__length = length
        self.__high = high

    # 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
    def tell_area(self):
        return self.__width * self.__length


# 使用者
room = Room('卧室', 'dream', 20, 20, 20)
# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 400

【3】更好的扩展性

# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self, name, owner, width, length, high):
        self.name = name
        self.owner = owner
        self.__width = width
        self.__length = length
        self.__high = high

    # 对外提供的接口，隐藏内部实现，
    # 此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,
    # 而且外部调用感知不到,仍然使用该方法，但是功能已经变了
    def tell_area(self):
        return self.__width * self.__length * self.__high


# 对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
room = Room('卧室', 'dream', 20, 20, 20)

# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 8000

__EOF__

本文作者：Fredette
本文链接：https://www.cnblogs.com/Fredette/p/17952527.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2024-01-08 15:20 Fredette 阅读(336) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Python回顾面向对象

· Python面向对象之面向对象编程

· 【2.0】Python面向对象之封装

· 【python】面向对象之封装

· Python面向对象的三大特性之封装

公告

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

发表于 2024-01-08 15:20阅读：336评论：0推荐：0

关注

跳至底部

昵称： Fredette
园龄： 1年3个月
粉丝： 1
关注： 3

+加关注

随笔分类

Python(2)

Fredette

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

【一】面向对象的三大特性

【1】什么是封装

【2】为什么要封装

【3】封装的方法

【二】隐藏属性

【1】隐藏属性方法

【2】问题

（1）隐藏属性访问

（2）隐藏方法变形

（3）变形操作只会发生一次

【三】开放接口

【1】隐藏数据属性

【四】装饰器property

【五】封装和扩展性

【1】设计者

【2】使用者

【3】更好的扩展性

公告

Fredette

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

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

推荐排行榜