第八篇：面向对象编程

Posted 2020-09-30

 

OOP介绍    

一、什么是OOP

1、编程的发展已经从简单控制流中按步的指令序列进入到更有组织的方式中

2、结构化的或过程性编程可以让我们把程序组织成逻辑块，以便重复或重用

3、面向对象编增强了结构化编程，实现了数据与动作的融合

4、数据层和逻辑层由一个可用以创建这些对象的简单抽象层来描述

 

 

二、常用术语
1、抽象/实现：抽象指对现实世界问题和实体的本质表现，行为和特征建模，建立一个相关的子集，可以用于描绘程序结构，从而实现这种模型

2、封装/接口：封装描述了对数据/信息进行隐藏的观念，它对数据属性提供接口和访问函数；客户端根本就不
需要知道在封装之后，数据属性是如何组织的，这就需要在设计时，对数据提供相应的接口

3、合成：合成扩充了对类的描述，使得多个不同的类合成为一个大的类，来解决现实问题

4、派生/继承：派生描述了子类的创建，新类保留已存类类型中所有需要的数据和行为，但允许修改或者其它的自定义操作，都不会修改原类的定义

5、多态：指出了对象如何通过他们共同的属性和动作来
操作及访问，而不需考虑他们具体的类

6、泛化/特化：泛化表示所有子类与其父类及祖先类有一样的特点；特化描述所有子类的自定义，也就是什么属性让它与其祖先类不同

7、自省/反射：自省表示给予程序员某种能力来进行像“手工类型检查”的工作，它也被称为反射。这个性质展示了某对象是如何在运行期取得自身信息的

 

类                              

一、创建类

1、类是一种数据结构，我们可以用它来定义对象，对象把数据值和行为特性融合在一起

2、python使用class关键字来创建类

3、通常类名的第一个字母大写

 

class ClassName(bases):
　　‘class documentation string‘ #‘类文档字符串‘
　　class_suite #类体

 

二、类的数据属性
1、数据属性仅仅是所定义的类的变量

2、这种属性已是静态变量，或者是静态数据。它们表示这些数据是与它们所属的类对象绑定的，不依赖于任何类实例

3、静态成员通常仅用来跟踪与类相关的值

>>> class C(object):
... foo = 100
...
>>> print C.foo
100
>>> C.foo += 1
>>> print C.foo
101

 

 

三、特殊的类属性

 

 

 实例                    

一、创建实例

1、如果说类是一种数据结构定义类型，那么实例则声明了一个这种类型的变量

2、类被实例化得到实例，该实例的类型就是这个被实例化的类

3、创建实例与调用函数类似，调用一个类就创建了它的一个实例

>>> class C(object):
... foo = 100
>>> c = C()
>>> print c
<__main__.C object at 0x7f4f012c1ad0> 

 

二、实例属性

1、实例仅拥有数据属性，数据属性只是与某个类的实例相关联的数据值，并且可通过句点属性标识法来访问

2、设置实例的属性可以在实例创建后任意时间进行，也可以在能够访问实例的代码中进行

>>> class C(object):
... pass
...
>>> c = C()
>>> c.hi = ‘hello‘
>>> print c.hi
hello

 

三、特殊的实例属性

>>> class C(object):
... pass
>>> c = C()
>>> c.hi = ‘hello‘
>>> c.__dict__
{‘hi‘: ‘hello‘}
>>> print c.__class__
<class ‘__main__.C‘>

 

 四、类与实例属性对比

1、类属性仅是与类相关的数据值，类属性和实例无关

2、静态成员（类的数据属性）不会因为实例而改变它们的值，除非实例中显式改变它

3、类和实例都是名字空间，各不相同

 

>>> class C(object):
... version = 1.0
>>> c = C()
>>> C.version += 0.1
>>> print ‘in C version=%s, in c version=%s‘ % (C.version, c.version)
in C version=1.1, in c version=1.1
>>> c.version += 0.1
>>> print ‘in C version=%s, in c version=%s‘ % (C.version, c.version)
in C version=1.1, in c version=1.2

 

 组合和派生

方法          

一、__init__方法
1、__init__()是实例创建后第一个被调用的方法
2、设置实例的属性可以在实例创建后任意时间进行，但是通常情况下优先在__init__方法中实现

#!/usr/bin/env python
class AddrBook(object):
    def __init__(self, nm, ph):
        self.name = nm
        self.phone = ph
>>> import AddrBook
>>> bob = AddrBook.AddrBook(‘bob green‘, ‘13322334455‘)

 

二、绑定方法

1、方法仅仅是类内部定义的函数，方法只有在其所属的类拥有实例时，才能被调用

2、任何一个方法定义中的第一个参数都是变量self，它表示调用此方法的实例对象

#!/usr/bin/env python
class AddrBook(object):
　　def getPhone(self):
　　　　return self.phone
>>> AddrBook.AddrBook.getPhone() #不能直接调用类的方法
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method getPhone() must be called with
AddrBook instance as first argument (got nothing instead)

 

三、非绑定方法

1、调用非绑定方法并不经常用到

2、需要调用一个没有实例的类中的方法的一个主要场景是你在派生一个子类，而且要覆盖父类的方法

 

#!/usr/bin/env python
class AddrBook(object):
    def __init__(self, nm, ph):
        self.name = nm
        self.phone = ph
    def getPhone(self):
        return self.phone

class EmplAddrBook(AddrBook):
    def __init__(self, nm, ph, id, em):
        AddrBook.__init__(self, nm, ph)
        self.emid = id
   　　 self.email = em            

 

组合

一、什么是组合

1、类被定义后，目标就是要把它当成一个模块来使用，并把这些对象嵌入到你的代码中去

2、组合就是让不同的类混合并加入到其它类中来增加功能和代码重用性

3、可以在一个大点的类中创建其它类的实例，实现一些其它属性和方法来增强对原来的类对象

 

二、实现组合

1、创建复合对象、应用组合可以实现附加的功能

2、例如，通过组合实现上述地址薄功能的增强

 

#!/usr/bin/env python
class Info(object):
　　def __init__(self, ph, em, qq):
　　　　self.phone = ph
　　　　self.email = em
　　　　self.qq = qq

　　def updatePhone(self, newph):
　　　　self.phone = newph

class Contact(object):
　　def __init__(self, name, ph, em, qq):
　　　　self.name = name
　　　　self.info = Info(ph, em, qq)

 

子类和派生

一、创建子类

1、当类之间有显著的不同，并且较小的类是较大的类所需要的组件时组合表现得很好；但当设计“相同的类
但有一些不同的功能”时，派生就是一个更加合理的选择了

2、OOP 的更强大方面之一是能够使用一个已经定义好的类，扩展它或者对其进行修改，而不会影响系统中使用现存类的其它代码片段

3、OOD（面向对象设计）允许类特征在子孙类或子类中进行继承

4、创建子类只需要在圆括号中写明从哪个父类继承即可

>>> class A(object):
... 　　def printStar(self):
... 　　　　print ‘*‘ * 20
...
>>> class B(A):
... pass
...

 

二、继承

1、继承描述了基类的属性如何“遗传”给派生类

2、子类可以继承它的基类的任何属性，不管是数据属性还是方法

 

>>> class A(object):
... 　　def printStar(self):
... 　　　　print ‘*‘ * 20
...
>>> class B(A):
... 　　pass #类B并没有定义任何方法
...
>>> b = B() #b是B的实例
>>> b.printStar() #B继承了类A的方法，实例b也就具备了该功能
******************* 

 

三、通过继承覆盖方法

1、如果子类中有和父类同名的方法，父类方法将被覆盖

2、如果需要访问父类的方法，则要调用一个未绑定的父类方法，明确给出子类的实例

 

>>> class P(object):
... 　　def foo(self):
... 　　　　print ‘in P-foo‘
>>> class C(P):
... 　　def foo(self):
... 　　　　print ‘in C-foo‘
>>> c = C()
>>> c.foo()
in C-foo
>>> P.foo(c)
in P-foo

 

四、多重继承

1、python允许多重继承，即一个类可以是多个父类的子类，子类可以拥有所有父类的属性

 

>>> class A(object):
... 　　def foo(self):
... 　　　　print ‘foo method‘
>>> class B(object):
... 　　def bar(self):
...　　　　 print ‘bar method‘
>>> class C(A, B):
... pass
>>> c = C()
>>> c.foo()
foo method
>>> c.bar()
bar method

 

五、类和实例的内建函数

 

 六、私有化
1、python为类元素（属性和方法）的私有性提供初步的形式，由双下划线开始的属性在运行时被“混淆”，所以直接访问是不允许的

>>> class C(object):
... 　　def __init__(self, nm):
... 　　　　self.__name = nm
... 　　def getName(self):
... 　　　　return self.__name
>>> c = C(‘bob‘)
>>> c.getName()
‘bob‘
>>> c.__name #私有化的数据不能在外部直接使用
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘C‘ object has no attribute ‘__name‘