面向对象三大特性之封装

面向对象编程有三大特性：
- 封装、继承、多态
其中最重要的一个特性就是封装。
- 封装指的就是把数据与功能都整合到一起
针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口

一、封装的介绍

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

二、隐藏属性

[1]隐藏属性的方法

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

class Student(object):
    name = 'name_1'
    _name = 'name_2'
    __name = 'name_3'

    def say(self):
        print(f'{self.name}say')

    def _say(self):
        print(f'{self.name}say')

    def __say(self):
        print(f'{self.name}say')

        
# 实例化出一个类
stu_1 = Student()
# 分别调用三个数据属性
print(stu_1.name)  # name_1
print(stu_1._name)  # name_2
# 双下划线开头的数据属性
print(stu_1.__name)  # AttributeError: 'Student' object has no attribute '__name'. Did you mean: '_name'?
# 分别调用三个函数属性
stu_1.say()  # name_1say
stu_1._say()  # name_1say
# 双下划线开头的方法无法找到
stu_1.__say()  # AttributeError: 'Student' object has no attribute '__say'. Did you mean: '_say'?

[2]问题

（1）隐藏属性的访问

（1）隐藏属性变形

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

class Student(object):
    name = 'name_1'
    _name = 'name_2'
    __name = 'name_3'

    
stu_1 = Student()
# 加上前缀_tudent就可以访问“隐藏”的__name
print(stu_1._Student__name)  # name_3

（2）隐藏方法访问

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

class Student(object):
    name = 'name_1'
    _name = 'name_2'
    __name = 'name_3'

    def get_name_3(self):
        print(self.__name)

stu_1 = Student()
stu_1.get_name_3()  # name_3

（3）变形只会发生一次

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

class Student(object):
    name = 'name_1'
    _name = 'name_2'
    __name = 'name_3'
	
    #定义__age对象属性为18
    def __init__(self):
        self.__age = "18"
        
# 实例化对象
stu_1 = Student()
# 修改对象的变量
stu_1.__name = 'Xanadu'
stu_1.__age = '22'
# 查看对象的名称空间
print(stu_1.__dict__)
# {'_Student__age': 18, '__name': 'Xanadu', '__age': '22'}
# 可以发现在外面添加的对象的变量并没有进行变形

三、开放接口

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

[1]隐藏数据属性

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制

class Student(object):
    def __init__(self, name, age):
        #进行格式校验
        if not isinstance(name, str):
            raise TypeError('姓名必须是字符串类型')
        if not isinstance(age, int):
            raise TypeError('年龄必须是整型')
        # 将用户输入的属性隐藏起来
        self.__name = name
        self.__age = age

    # 开放接口让外部可以查看学生的信息
    def show_student_info(self):
        print('姓名:%s,年龄:%s' % (self.__name, self.__age))

    # 开放接口让外部可以修改学生的信息
    def change_student_info(self, name, age):
        #进行格式校验
        if not isinstance(name, str):
            raise TypeError('姓名必须是字符串类型')
        if not isinstance(age, int):
            raise TypeError('年龄必须是整型')
        # 将用户输入的属性隐藏起来
        self.__name = name
        self.__age = age

stu_1 = Student("桃源氏", 22)
# 格式校验失败就报错
stu_1 = Student("桃源氏", '18')  # TypeError: 年龄必须是整型
stu_1.show_student_info()  # 姓名:桃源氏,年龄:22
stu_1.change_student_info('小桥', 22)
# 格式校验失败就报错
stu_1.change_student_info({'小桥'}, 22)  # TypeError: 姓名必须是字符串类型
stu_1.show_student_info()  # 姓名:小桥,年龄:22

[2]隐藏函数属性

目的是为了隔离复杂度
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
  - 比如身份认证、输入金额、余额校验等
- 而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来

class ATM(object):
    # 将除了暴露出来的取款接口以外的其他接口全部隐藏
    def __check(self):
        print('校验身份')

    def __get_amount(self):
        print('输入金额')

    def __check_balance(self):
        print('校验余额')

    # 提供整合之后的取款接口
    def withdraw(self):
        self.__check()
        self.__get_amount()
        self.__check_balance()
        print('取款结束！')


user_1 = ATM()
user_1.withdraw()
'''
校验身份
输入金额
校验余额
取款结束！
'''

[3]小结

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

四、装饰器`property`

[1]什么是`property`

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

class Wages(object):

    def __init__(self, posts, days):
        self.posts = posts
        self.days = int(days)
        self.level_dict = {
            'level1': 0.1,
            'level2': 0.2,
            'level3': 0.3
        }

    @property
    def __daily(self):
        if self.posts == '普通员工':
            return 300
        elif self.posts == '经理':
            return 1000

    @property
    def __level(self):
        if self.wages > 5000:
            return 'level1'
        elif self.wages > 10000:
            return 'level2'
        else:
            return 'level3'

    @property
    def __tax(self):
        return self.wages * self.level_dict[self.__level]

    @property
    def wages(self):
        return self.__daily * self.days

    @property
    def ture_wages(self):
        return self.wages - self.__tax


my_wages = Wages('普通员工', 30)

print(my_wages.wages)  # 9000
print(my_wages.ture_wages)  # 8100.0

[2]为什么要用`property`

将一个类的函数定义成特性以后，对象再去使用的时候my_wages.wages,根本无法察觉自己的wages是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
面向对象的封装有三种方式:
- 【public】
  - 这种其实就是不封装,是对外公开的
- 【protected】
  - 这种封装方式对外不公开
- 【private】
  - 这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class Wages(object):

    def __init__(self, posts, days):
        self.__posts = posts
        self.__days = int(days)

    @property
    def __level_dict(self):
        return {
            '1': 0.1,
            '2': 0.2,
            '3': 0.3
        }

    @property
    def posts(self):
        return self.__posts

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

    @posts.deleter
    def posts(self):
        raise PermissionError('Can not delete')
        
 	@property
    def __daily(self):
        if self.__posts == '普通员工':
            return 300
        elif self.__posts == '经理':
            return 1000

    @property
    def __level(self):
        if self.wages > 5000:
            return '1'
        elif self.wages > 10000:
            return '2'
        else:
            return '3'

    @property
    def __tax(self):
        return self.wages * self.__level_dict[self.__level]

    @property
    def wages(self):
        return self.__daily * self.__days

    @property
    def ture_wages(self):
        return self.wages - self.__tax


my_wages = Wages('普通员工', 30)
# 触发posts.setter装饰器对应的函数posts(self, value)
my_wages.posts = "经理"
# 将posts改成经理之后工资也就变了
print(my_wages.wages)  # 30000
print(my_wages.ture_wages)  # 27000.0

class Wages(object):

    def __init__(self, posts, days):
        self.__posts = posts
        self.__days = int(days)

    @property
    def __level_dict(self):
        return {
            '1': 0.1,
            '2': 0.2,
            '3': 0.3
        }
    
    def get_posts(self):
        return self.__posts

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

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

    posts = property(get_posts, set_posts, del_posts)

    @property
    def __daily(self):
        if self.__posts == '普通员工':
            return 300
        elif self.__posts == '经理':
            return 1000

    @property
    def __level(self):
        if self.wages > 5000:
            return '1'
        elif self.wages > 10000:
            return '2'
        else:
            return '3'

    @property
    def __tax(self):
        return self.wages * self.__level_dict[self.__level]

    @property
    def wages(self):
        return self.__daily * self.__days

    @property
    def ture_wages(self):
        return self.wages - self.__tax


my_wages = Wages('普通员工', 30)
# 触发posts.setter装饰器对应的函数posts(self, value)
my_wages.posts = "经理"
# 将posts改成经理之后工资也就变了
print(my_wages.wages)  # 9000
print(my_wages.ture_wages)  # 8100.0

五、封装和拓展性

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

[1]设计者

class Wages(object):

    def __init__(self, posts, days):
        self.__posts = posts
        self.__days = int(days)
       
	# 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是工资
	@property
    def wages(self):
        return self.__daily * self.__days

[2]使用者

class Wages(object):

    def __init__(self, posts, days):
        self.__posts = posts
        self.__days = int(days)
       
	# 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是工资
	@property
    def wages(self):
        return self.__daily * self.__days 
    
# 使用者    
my_wages = Wages('普通员工', 30)
# 使用者调用接口wages
print(my_wages.wages)  # 9000

[3]更好的扩展性

# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Wages(object):

    def __init__(self, posts, days):
        self.__posts = posts
        self.__days = int(days)
       
	# 对外提供的接口，隐藏内部实现，
    # 此时我们想求的是税后工资,内部逻辑变了,只需求修该下列一行就可以很简答的实现,
    # 而且外部调用感知不到,仍然使用该方法，但是功能已经变了
	@property
    def wages(self):
        return self.__daily * self.__days * 0.8
    
# 对于仍然在使用wages接口的人来说，根本无需改动自己的代码，就可以用上新功能   
my_wages = Wages('普通员工', 30)
# 使用者调用接口wages
print(my_wages.wages)  # 9000

posted @ 2024-01-29 14:42 桃源氏阅读(38) 评论(0) 收藏举报

刷新页面返回顶部

桃源氏

面向对象三大特性之封装

面向对象三大特性之封装

一、封装的介绍

二、隐藏属性

[1]隐藏属性的方法

[2]问题

（1）隐藏属性的访问

（1）隐藏属性变形

（2）隐藏方法访问

（3）变形只会发生一次

三、开放接口

[1]隐藏数据属性

[2]隐藏函数属性

[3]小结

四、装饰器property

[1]什么是property

[2]为什么要用property

五、封装和拓展性

[1]设计者

[2]使用者

[3]更好的扩展性

公告

四、装饰器`property`

[1]什么是`property`

[2]为什么要用`property`