面向对象之封装

Posted panshao51km-cn

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象之封装相关的知识,希望对你有一定的参考价值。

一、封装

  1.什么是封装?

  在程序设计当中,封装是对具体对象的一种抽象,也就是说将某些部分隐藏起来,程序外部访问不到,其含义是其他程序无法调用的。

  要了解封装,离不开“私有化”,就是将类或者是函数中的某些属性限制在某个区域之内,外部无法调用。

  2.为什么要封装?

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

  封装方法的主要原因:隔离复杂度(比如:洗衣机,我们看见的就是一个黑匣子,其实里面有很多电器元件,对于用户来说,我们不清楚里面都有哪些元件,电视机把那些电器元件封装在黑匣子里,提供给用户的只是几个按钮接口,通过按钮来操作洗衣机)

  3.被封装的两个特点:外界不能直接访问,内部依然可以使用。

二、封装两个层面

  封装分为两层,但无论哪种层面的封装,都要对外界提供好访问你内部隐藏内容的接口(这个接口我们暂时可以理解为入口,有了这个入口,使用者无需且不能够直接访问到内部隐藏的细节,只能走接口,而且可以在接口的实现上附加更多的逻辑,来控制使用者的访问)

  第一层面的封装(什么都不用做):创建类和和对象会分别创建二者的名称空间,我们只能用类名或者obj.的方式去访问里面的名字,这本身就是一种封装。

  第二层的封装:类中把某些属性和方法隐藏起来(或者说定义成私有的),只在类的内部使用,外部无法访问,或者留下少量接口供外部访问。

  在python中私有化的方法也比较简单,即在私有化的属性(包括方法,数据)名字前面加两个下划线就行。

  类中所有双下划线开头的名称如_x都会自动变形成:类名_x的形式:

class A:

    __N = 0   """# 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的
    如__N,都会变形为_A__N"""

    def __init__(self):
        self.__x = 10   # 变形为self._A__X

    def __foo(self):     # 变形为_A__foo

        print(‘from A‘)

    def bar(self):
        self.__foo()    #  只有在内部才可以通过__foo的形式访问到
        
    # A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是语法意义上的变形

  这种自动变形的特点:

  1.类中定义的__x只能在外部使用,如self.__x,引用的就是变形的结果。

  2.这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。

  3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变成了:_子类名__x,而父类中变形成了:_父类名__x,即双下划线开头的属性在继承给子类时,子类是无法覆盖的。

  这种变形需要注意的问题是:

  1.这种机制也并没有真正意义上限值我们从外部直接访问属性,知道了类名和属性名就可拼出名字:类名_属性,然后就可以访问了,如a._A__N

  2.变量的过程只在类的定义是发生一次,在定义后的赋值操作,不会变形

a = A()           # 实例化对象a
print(a.__dict__)   # 打印变形的内容
a._Y = 20        # 新增Y的值,此时加__不会变形
print(a.__dict__)   # 打印变形的内容
========输出结果========
‘_A__X‘:10
‘_A__X‘:10,‘__Y‘:20  # 发现后面的Y并没有变形

  3.在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

class A :
    def fa(self):
        print("from A")

    def test(self):
        self.fa()


class B(A):
    def fa(self):
        print("from B")


b = B()
b.test()
=====输出结果=====
from B

  我们来看下fa被定义成私有的情况:

class A:     # 把fa定义成私有的,即__fa
    def __fa(self):      # 在定义时就变形为_A__fa
        print("from A")

    def test(self):
        self.__fa()     # 只会与自己所在的类为准,即调用_A__fa

class B(A):
    def __fa(self):    # b调用的是test,跟这个没关系
        print("from B")


b = B()
b.test()
====输出结果====
from A

三、特性(property)

  1.什么是特性property

  property是一种特殊的属性,在访问它时会执行一段功能(函数)然后返回值(就是装饰器)

  注意:被property装饰的属性会优先于对象的属性被使用,而被propery装饰的属性,分成三种:property、被装饰的函数名.setter、被装饰的函数名.deleter(都是以装饰器的形式)。

class room:    # 定义一个房间的类
    def __init__(self,length,width,high):
        self.length = length        #   房间的长
        self.width = width          #    房间的宽
        self.high = high       # 房间的高

    @property
    def area(self):     # 求房间的平方的功能
        return self.length * self.width         #房间的面积就是:长*宽
    @property
    def perimeter(self):          # 求房间的周长的功能
        return 2 * (self.length + self.width)      # 公式为:(长+宽)*2
    @property
    def volume(self):       # 求房间的体积的功能
        return self.length * self.high      #公式为:长*款*高

# 实例化一个对象r1
r1 = room(1, 2, 3)  
  # 可以像访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print("r1,area:",r1.area)
# 同上 ,就不用想调用绑定方法一样,还得加括号才能运行
print("r1.perimeter:",r1.perimeter)
# 同上  就像是把运算过程封装到一个函数内部,我们不管过程,只要有结果就行
print("r1.volume:",r1.volume )
 ====输出答案====
r1,area: 2
r1.perimeter: 6
r1.volume: 3

  此时的area、perimeter和volume不能被赋值。

  2、为什么要用property

  将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的names是执行一个函数然后计算出来的,这种特性的使用方式遵循了统一访问原则。

class People:      # 定义一个人的类
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex   # p1.sex = "male",遇到property,优先使用

    @property   # 查看sex的值
    def sex(self):
        return self.__sex   # 返回真正存值的地方

    @sex.setter   # 修改sex的值
    def sex(self,value):
        if not isinstance(value, str):# 在设定值之前进行类型检查
            raise TypeError("性别必须是字符串类型")  # 不是str类型时,主动抛出异常
        self.__sex = value    # 类型正确的时候,直接修改__sex的值,这是值真正存在的地方
        # 这里sex前加"__",对sex变形,隐藏。

    @sex.deleter     # 删除sex
    def sex(self):
        del self.__sex


p1 = People("egon","male")  # 实例化对象p1
print(p1.sex)   # 查看p1的sex,此时要注意self.sex的优先级
p1.sex = "female"# 修改sex的值
print(p1.sex)  # 查看修改后的p1的sex
print(p1.__dict__)# 查看p1的名称空间,此时里面有sex
del p1.sex   # 删除p1的sex
print(p1.__dict__)  # 查看p1的名称空间,此时发现里面已经没有sex了


=====输出结果=====

male
female
‘name‘: ‘egon‘, ‘_People__sex‘: ‘female‘
‘name‘: ‘egon‘

四、封装与扩展性

  封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用者只知道一个接口(函数),只要接口(函数名)、参数不变,使用者的代码无需改变 

class room:    # 定义一个房间的类
    def __init__(self,name,owner,length,width,high):
        self.name = name
        self,owner = owner
        self.__length = length         # 房间的长
        self.__width = width            # 房间的宽
        self.__high = high             # 房间的高
    
    @property
    def area(self):   # 求房间的平方的功能
        return self.__length * self.__width#对外提供的接口,隐藏了内部的实现细节,此时我们想求的是房间的面积就是:长 * 宽

  实例化对象通过接口,调用相关属性得到想要的值:

r1 = room("客厅","michael","20","30","9")  # 实例化一个对象r1
print(r1.area)   # 通过接口 使用(area),使用者得到了客厅的面积


====输出结果====
600 #得到了客厅的面积

  扩展原有的代码,使功能增加:

class room: #定义一个房间的类
def __init__(self,name,owner,length,width,high):
    self.name = name #房间名
    self.owner = owner #房子的主人
    self.__length = length #房间的长
    self.__width = width #房间的宽
    self.__high = high #房间的高
@property
def area(self): #对外提供的接口,隐藏内部实现
    return self.__length * self.__width,           self.__length * self.__width * self.__high #此时我们增加了求体积,
    # 内部逻辑变了,只需增加这行代码就能简单实现,而且外部调用感知不到,仍然使
    # 用该方法,但是功能已经增加了

  对于类的使用者,仍然在调用area接口的人来说,根本无需改动自己的代码,就可以用上新功能:

r1 = room("客厅","michael",20,30,9) #实例化一个对象r1
print(r1.area) #通过接口使用(area),使用者得到了客厅的面积
--------------输出结果---------------
(600, 5400) #得到了新增的功能的值

  

 

 

 

 

 

 

  

 

 

 

  

 

  

以上是关于面向对象之封装的主要内容,如果未能解决你的问题,请参考以下文章

python之面向对象之封装

面向对象之封装和继承

面向对象三大特性之封装

面向对象三大特性之封装

面向对象之:封装,多态

Python面向对象之封装