面向对象学习目录
引子
从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’，当然，这种理解是相当片面的。
先看如何隐藏
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
1 #其实这仅仅这是一种变形操作 2 #类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： 3 4 class A: 5 __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N 6 def __init__(self): 7 self.__X=10 #变形为self._A__X 8 def __foo(self): #变形为_A__foo 9 print('from A') 10 def bar(self): 11 self.__foo() #只有在类内部才可以通过__foo的形式访问到. 12 13 #A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
这种自动变形的特点：
- 类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
- 这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
- 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，虽然不会这么做
2、变形的过程只在类的定义时发生，且仅变形一次，在类定义外的赋值操作，不会变形
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
1 #正常情况 2 >>> class A: 3 ... 4 def fa(self): 5 ... 6 print('from A') 7 ... 8 def test(self): 9 ... 10 self.fa() 11 ... 12 >>> class B(A): 13 ... 14 def fa(self): 15 ... 16 print('from B') 17 ... 18 >>> b=B() 19 >>> b.test() 20 from B 21 22 23 #把fa定义成私有的，即__fa 24 >>> class A: 25 ... 26 def __fa(self): #在定义时就变形为_A__fa 27 ... 28 print('from A') 29 ... 30 def test(self): 31 ... 32 self.__fa() #只会与自己所在的类为准,即调用_A__fa 33 ... 34 >>> class B(A):... 35 def __fa(self): 36 ... 37 print('from B')、 38 ... 39 >>> b=B() 40 >>> b.test() 41 from A
封装不是单纯意义的隐藏
1：封装数据
将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。
1 class Teacher: 2 def __init__(self,name,age): 3 self.__name=name 4 self.__age=age 5 6 def tell_info(self): 7 print('姓名:%s,年龄:%s' %(self.__name,self.__age)) 8 def set_info(self,name,age): 9 if not isinstance(name,str): 10 raise TypeError('姓名必须是字符串类型') 11 if not isinstance(age,int): 12 raise TypeError('年龄必须是整型') 13 self.__name=name 14 self.__age=age 15 16 t=Teacher('egon',18) 17 t.tell_info() 18 19 t.set_info('egon',19) 20 t.tell_info()
2：封装方法：目的是隔离复杂度
1 #取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱 2 #对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做 3 #隔离了复杂度,同时也提升了安全性 4 5 class ATM: 6 def __card(self): 7 print('插卡') 8 def __auth(self): 9 print('用户认证') 10 def __input(self): 11 print('输入取款金额') 12 def __print_bill(self): 13 print('打印账单') 14 def __take_money(self): 15 print('取款') 16 17 def withdraw(self): 18 self.__card() 19 self.__auth() 20 self.__input() 21 self.__print_bill() 22 self.__take_money() 23 24 a=ATM() 25 a.withdraw()
封装方法的其他举例：
- 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
- 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
- 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数。
接口函数，与接口的概念还不一样，接口代表一组接口函数的集合体。
特性（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
1 class People: 2 def __init__(self,name,weight,height): 3 self.name=name 4 self.weight=weight 5 self.height=height 6 @property 7 def bmi(self): 8 return self.weight / (self.height**2) 9 10 p1=People('egon',75,1.85) 11 print(p1.bmi)
例二：圆的周长和面积
1 import math 2 class Circle: 3 def __init__(self,radius): #圆的半径radius 4 self.radius=radius 5 6 @property 7 def area(self): 8 return math.pi * self.radius**2 #计算面积 9 10 @property 11 def perimeter(self): 12 return 2*math.pi*self.radius #计算周长 13 14 c=Circle(10) 15 print(c.radius) 16 print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值 17 print(c.perimeter) 18 #同上 19 ''' 20 输出结果: 21 10 22 314.1592653589793 23 62.83185307179586 24 '''
注意：此时的特性area和perimeter不能被赋值！
1 c.area=3 #为特性area赋值 2 ''' 3 抛出异常: 4 AttributeError: can't set attribute 5 '''
为什么要用property？
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则（将函数计算得到的数值结果也以数据属性方式访问）。
除此之外，看下面的介绍——
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
1 class Foo: 2 def __init__(self,val): 3 self.__NAME=val #将所有的数据属性都隐藏起来 4 5 @property 6 def name(self): 7 return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置) 8 9 @name.setter 10 def name(self,value): 11 if not isinstance(value,str): #在设定值之前进行类型检查 12 raise TypeError('%s must be str' %value) 13 self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME 14 15 @name.deleter 16 def name(self): 17 raise TypeError('Can not delete') 18 19 f=Foo('egon') 20 print(f.name)# f.name=10 #抛出异常'TypeError: 10 must be str' 21 del f.name #抛出异常'TypeError: Can not delete'
封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
1 #类的设计者 2 class Room: 3 def __init__(self,name,owner,width,length,high): 4 self.name=name 5 self.owner=owner 6 self.__width=width 7 self.__length=length 8 self.__high=high 9 def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积 10 return self.__width * self.__length
#使用者，一旦实例化r1房间，则r1房间的宽、长、高固定，无法修改 >>> r1=Room('卧室','egon',20,20,20) >>> r1.tell_area() #使用者调用接口tell_area
1 #类的设计者，轻松的扩展了功能（从计算面积变成计算体积），而类的使用者完全不需要改变自己的代码 2 class Room: 3 def __init__(self,name,owner,width,length,high): 4 self.name=name 5 self.owner=owner 6 self.__width=width 7 self.__length=length 8 self.__high=high 9 def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了 10 return self.__width * self.__length * self.__high
#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能 >>> r1.tell_area()