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

面向对象之封装

一 引子

从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。在面向对象中，麻袋就是你的类或者对象，类或者对象这俩麻袋内部装有数据属性和函数属性。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的。

封装的本质是要明确地区分内外。是的类实现者可以修改封装内的东西而不影响外部调用者；而外部调用者也可以知道自己不可以碰哪里，从而提供了一个良好的合作基础。只要接口这个基础约定不变，则代码改变不足为虑。

二 先看如何隐藏

在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的形式访问到.

#这种，在外部是无法通过__x这个名字访问到。
#但可以通过 obj._A__N是可以访问到的。

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

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。

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

对于两种不同的编码约定（单下划线和双下划线）来命名私有属性的选用：

（1）非公共名称以单下划线开头

（2）若代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划綫

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

 View Code

三 封装不是单纯意义的隐藏

封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，那这么做的意义何在？？？

1：封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

 View Code

2：封装方法：目的是隔离复杂度

封装方法举例： 

1. 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。

2. 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！

3. 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

 隔离复杂度的例子

3: 了解

有三个层面的封装：

第一层面是类本身就是一种封装。

第二层面是类中定义私有的，只有在类的内部使用，外部无法访问（实际通过找到修改后的名字还是可以访问的）。

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的。

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点。对于双下划线开头的外部可以通过对象obj结合类名A：通过 obj._A__N访问到。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class People:
    __star='earth111111111111'
    __star1='earth111111111111'
    __star2='earth111111111111'
    __star3='earth111111111111'
    def __init__(self,id,name,age,salary):
        print('----->',self.__star)   #能够成功访问自己内部的双下划綫的
        self.id=id
        self.name=name
        self.age=age
        self.salary=salary

    def get_id(self):
        print('我是私有方法啊,我找到的id是[%s]' %self.id)

    #访问函数/接口函数：内部访问双下划綫的数据
    def get_star(self):     
        print(self.__star)    #通过这个函数可以访问到内部的一个访问接口

p1=People('123123123123','alex','18',100000000)
# print(p1.__star)    #双下划线开头的__star函数，外部对象不能直接访问
print(People.__dict__)   #查看装了什么
# print(p1.__star)
print(p1._People__star)  #外部不能直接访问，但像这样就可以访问到了。所以不是真正的限制，只是一种约定。

# p1.get_star()   #不可以
p1.get_star()    #因此实例可以通过调用类内部的函数来访问
# 因此，封装实质就是区分内外，内部就是能用，外部不能直接用
第二层面

第三层面的封装才是真的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用。

这样做的好处是，为外部类的使用者提供一个方便访问，原有已经定义好的内置私有数据的“接口”。

但如果定义了太多不该对外部隐藏的数据，后续又通过这种“凿洞”的方式，很可能把程序弄得千疮百孔。所以定义双下划线之前一定要想清楚。

（这或许也可以用来解释为什么python被设计为非严格限制外部对内部私有属性的访问，从而避免滥用封装。）

python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__，详见面向对象进阶。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

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

    def tell_width(self):
        return self.__width    
    #不能采用直接去掉双下划线变width供外部使用，因为__width很可能会在别的逻辑中被调用了
    #如果贸然修改，很可能出现很多错误、很多需要修改的

r1=Room('卫生间','alex',100,100,10000)

# arear=r1.__width * r1.__length   #不给访问
print(r1.tell_area())
第三层面

 

四 特性(property) 

什么是特性property

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

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86
 View Code

例二：圆的周长和面积 

 View Code
#注意：此时的特性arear和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

为什么要用property

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

除此之外，看下

复制代码
ps：面向对象的封装有三种方式:
【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 #obj.name访问的是self.__NAME(这也是真实值的存放位置)

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

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

f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'
复制代码
 了解：一种property的古老用法

五 封装与扩展性

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

 View Code
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Josie-chen/p/8864958.html