复习----面向对象（一）

1，什么是面向对象？

         面向对象是一种编程思想，是一种“上帝”思想，是把现实中的一些相类似事物定义成一个类，然后产生出一个对象，这个对象具有这个类的方法和属性。

      什么是类：类是一系列对象相似方法和特征的结合体。

      什么是对象：一切皆对象，对象时特征与技能的结合体，对象具有被实例的类的方法和属性。

 

2，面向对象的三大特性：

          1，继承

       在Python中，可以让一个类去继承一个类，被继承的类称为父类或者超类、也可以称作基类，继承的类称为子类。并且Python支持多继承，能够让一个子类有多个父类。

 

    1）在Python中，如果父类和子类都重新定义了构造方法__init( )__，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。

 

　　2）如果需要在子类中调用父类的方法，需要以   父类名.方法  这种方式调用，以这种方式调用的时候，注意要传递self参数过去。

 

　　对于继承关系，子类继承了父类所有的公有属性和方法，可以在子类中通过父类名来调用，而对于私有的属性和方法，子类是不进行继承的，因此在子类中是无法通过父类名来访问的。

 

　　对于多重继承，比如

 

　　class SubClass(SuperClass1,SuperClass2)

 

　　此时有一个问题就是如果SubClass没有重新定义构造方法，它会自动调用哪个父类的构造方法？这里记住一点：以第一个父类为中心。如果SubClass重新定义了构造方法，需要显示去调用父类的构造方法，此时调用哪个父类的构造方法由你自己决定；若SubClass没有重新定义构造方法，则只会执行第一个父类的构造方法。并且若SuperClass1和SuperClass2中有同名的方法，通过子类的实例化对象去调用该方法时调用的是第一个父类中的方法。

       继承的super（）方法：

      super（）方法是用来调用父类方法的内置方法，它是用来解决多继承时调用顺序的，只能使用在新式类

     什么是新式类：继承了object的类叫新式类，在python3中所有的类都是新式类。

     什么是经典类：没有继承object的类叫经典类，只有在python中才有经典类

     在菱形继承关系中：

        新式类：继承关系是广度优先

        经典类：继承关系是深度优先

class hello(object):
...         def print_c(self):
...             print"hello world!"
...
>>> class child(hello):
...         def print_c(self):
...                 super(child,self).print_c()
...
>>> child().print_c()
hello world!

 

          2，封装

       在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。在编程语言里，对外提供的接口（接口可理解为了一个入口），就是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体，外部想要调用被封装的方法就需要通过接受来调用，我们就可以在这个接口里写一些逻辑判断来限制你的调用。

              语法：在要被封装的方法前加双下划线：__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的形式访问到.　

这种自动变形的特点：

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

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

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

注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

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

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

a = A()
print(a._A__N)
print(a._A__X)
print(A._A__N) --------输出结果-------- 0 10 0

 

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）：

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 #房间的面积就是：长x宽 @property def perimeter(self): #求房间的周长的功能 return 2 * (self.length + self.width) #公式为：（长 + 宽）x 2 @property def volume(self): #求房间的体积的功能 return self.length * self.width * self.high #公式为：长 x 宽 x 高 r1 = room(2,3,4) #实例化一个对象r1 print("r1.area：",r1.area) #可以像访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值 print("r1.perimeter：",r1.perimeter) #同上，就不用像调用绑定方法一样，还得加括号，才能运行 print("r1.volume：",r1.volume) #同上，就像是把运算过程封装到一个函数内部，我们不管过程，只要有结果就行 ------------输出结果--------------- r1.area： 6 r1.perimeter： 10 r1.volume： 24

注意：此时的特性arear、perimeter和volume不能被赋值。

r1.area = 8 #为特性area赋值
r1.perimeter = 14 #为特性perimeter赋值
r1.volume = 24 #为特性volume赋值
'''
抛出异常：
    r1.area = 8 #第一个就抛异常了，后面的也一样
AttributeError: can't set attribute
 
'''

2、为什么要用property

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

class people: #定义一个人的类
    def __init__(self,name,sex): self.name = name self.sex = sex #p1.sex = "male",遇到property，优先用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'}

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

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

         3，多态

多态是指一种事物的多种形态

python支持多态，python本身就是一种多态语言。

python推崇的是“鸭子类型”

“  当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

python程序员通常根据这种行为来编写程序，如果想编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松藕合度，python推崇后者的方式。

例：序列类型有多种形态：字符串，列表，元组，但是他们没有直接继承关系

          s  =   str ("hello")

          l   =    list([1,2,3])

         t    =   tuple((4,5,6))

       #我们可以在不考虑三者类型的前提下使用 s，l ，t

         s.__len__()

         l.__len__()

         t.__len__()

         len(s)

         len(l)

         len(t)