【python】面向对象之封装

一：面向对象编程有三大特性：
- 封装、继承、多态
二：其中最重要的一个特性就是封装。
- 封装指的就是把数据与功能都整合到一起
三：什么是封装？
- 1.数据角度讲，将一些基础数据类型复合成一个自定义类型
- 2.行为角度讲，向类外提供必要的功能，隐藏实现的细节
- 3.设计角度
  - 分而治之
    - 将一个大的需求分解成许多类，每个类处理一个独立的功能
    - 拆分的好处，便于分工，便于复合，可扩展性强
  - 变则疏之
    - 变化的地方独立封装，避免影响其他类
  - 高内聚
    - 类中的各个方法都在完成一项任务
  - 低耦合
    - 类与类的关联性与依懒性要低
四：隐藏属性
- 1.Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的）
- 2.但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成_类名__属性名的形式：

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.__NAME)   #object 'Person' has no attribute '__NAME'
obj = Person()
# print(obj.__NAME)    #'Person' object has no attribute '__NAME'
print(obj.__dict__)   #{'_Person__age': 18}
print(Person.__dict__)
"""
{'__module__': '__main__', '_Person__NAME': 'ZHANG', '__init__': <function Person.__init__ at 0x0000017F3CE3C5E0>, 
'_Person__run': <function Person.__run at 0x0000017F3CE3C790>, 'walk': <function Person.walk at 0x0000017F3D0B2C10>, 
'__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, 
'__doc__': None}
"""

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

五：开发接口
- 1.定义属性就是为了使用，所以隐藏并不是目的
- 2.将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
- 3.目的的是为了隔离复杂度
  - 例如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()
# 插卡
# 用户认证
# 输入取款金额
# 打印账单
# 取款

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

六：装饰器property
- 1.将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
- 2.初版

class Wife:
    def __init__(self,name,age,weight):
        self.name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # self.__age = age
        # self.set_age(age)   # 缺点：看着不方便，不像数据
        self.age = age
        self.weight = weight

    # 提供公开的读写方法
    def get_age(self):
        return self.__age

    def set_age(self,value):
        if 21 <= value <= 31:
            self.__age = value
        else:
            raise ValueError("不行")

    # 实例变量使用 self.age = age, 配合property
    age = property(get_age, set_age)

"""
w01 = Wife("白雪公主",22,90)
# 重新创建了实例变量，没有改变类中定义的__age
# w01.__age = 88
# 修改了类中定义的私有变量
w01._Wife__age = 88
print(w01.__dict__)  # __dict__内置变量，存储对象的实例变量
"""

w01 = Wife("白雪公主",21,90)
print(w01.get_age())
print(w01.__dict__)

3.最终版

class Wife:
    def __init__(self,name,age,weight):
        self.name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # self.__age = age
        # self.set_age(age)   # 缺点：看着不方便，不像数据
        self.age = age
        self.weight = weight

    # 提供公开的读写方法
    @property  # 创建property对象，只负责读取操作
    def age(self):
        return self.__age

    @age.setter  # 只负责拦截写入操作
    def age(self,value):
        if 21 <= value <= 31:
            self.__age = value
        else:
            raise ValueError("不行")

    # 实例变量使用 self.age = age, 配合property
    # age = property(get_age, set_age)


w01 = Wife("白雪公主",23,90)
w01.age = 11
print(w01.__dict__)

七：封装与扩展性
- 1.封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；
- 2.而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变
- 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


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

#更好的扩展性

# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
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

posted @ 2024-08-21 21:04 Tony_xiao 阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

Tony_xiao

【python】面向对象之封装

公告