封装

封装

博客部分解释封装是:将对象具体实现细节和属性隐藏起来,仅对外提供公共访问方式

python书中解释:封装是指程序中的其他部分隐藏对象的具体实现细节的原则.和多态一样,也是使用对象而不用知道其具体内部细节,多态和封装都是抽象原则.他们会帮助处理程序组建而不用关心多于细节,就像函数一样

.

好处

1.将变化隔离

2.便于使用

3,提高复用性

4,提高安全性

原则

1.将不需要对外提供的内容,都隐藏起来

2.把属性都隐藏,提供公共方法对其访问

在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. 将变化隔离；
##
##2. 便于使用；
##
##3. 提高复用性；
##
##4. 提高安全性；
##
##【封装原则】
##
##1. 将不需要对外提供的内容都隐藏起来；
##
##2. 把属性都隐藏，提供公共方法对其访问。

##二 私有变量和私有方法
##
##在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.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

##私有方法
##
##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定义成私有的，即__fa
##>>> class A:
##... def __fa(self): #在定义时就变形为_A__fa
##... print('from A')
##... def test(self):
##... self.__fa() #只会与自己所在的类为准,即调用_A__fa
##...
##>>> class B(A):
##... def __fa(self):
##... print('from B')
##...
##>>> b=B()
##>>> b.test()
##from A

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

复制代码
#类的设计者
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

#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area

#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
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接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()