博客部分内容转自：http://www.cnblogs.com/wupeiqi/p/4493506.html

面向对象编程介绍

为什么要用面向对象进行开发？

面向对象的特性：封装、继承、多态

类、方法

面向对象编程介绍

  • 面向过程：根据业务逻辑从上到下写垒代码 (如：编写备份代码，第一步做什么，第二部做什么……)
  • 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
  • 面向对象：对函数进行分类和封装，让开发“更快更好更强...” (如：cs游戏中，角色就是一个对象，对这个角色进行编程）

对于编程语言的初学者来讲，OOP不是一个很容易理解的编程方式，大家虽然都按老师讲的都知道OOP的三大特性是继承、封装、多态，并且大家也都知道了如何定义类、方法等面向对象的常用语法，但是一到真正写程序的时候，还是很多人喜欢用函数式编程来写代码，特别是初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发现在使用了面向对象后，对我们的程序开发效率或其它方面带来什么好处，因为我使用函数编程就可以减少重复代码并做到程序可扩展了，为啥子还用面向对象？”。

 

无论用什么形式来编程，我们都要明确记住以下原则：

  1. 写重复代码是非常不好的低级行为
  2. 你写的代码需要经常变更

开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

 

如果你把一段同样的代码复制、粘贴到了程序的多个地方以实现在程序的各个地方调用 这个功能，那日后你再对这个功能进行修改时，就需要把程序里多个地方都改一遍，这种写程序的方式是有问题的，因为如果你不小心漏掉了一个地方没改，那可能会导致整个程序的运行都 出问题。 因此我们知道 在开发中一定要努力避免写重复的代码，否则就相当于给自己再挖坑。如：

  1 while True：
  2     if cpu利用率 > 90%:
  3         #发送邮件提醒
  4         连接邮箱服务器
  5         发送邮件
  6         关闭连接
  7  
  8     if 硬盘使用空间 > 90%:
  9         #发送邮件提醒
 10         连接邮箱服务器
 11         发送邮件
 12         关闭连接
 13  
 14     if 内存占用 > 80%:
 15         #发送邮件提醒
 16         连接邮箱服务器
 17         发送邮件
 18         关闭连接

还好，函数的出现就能帮我们轻松的解决重复代码的问题，对于需要重复调用的功能，只需要把它写成一个函数，然后在程序的各个地方直接调用这个函数名就好了，并且当需要修改这个功能时，只需改函数代码，然后整个程序就都更新了。如：

  1 def 发送邮件(内容)
  2     #发送邮件提醒
  3     连接邮箱服务器
  4     发送邮件
  5     关闭连接
  6  
  7 while True：
  8  
  9     if cpu利用率 > 90%:
 10         发送邮件('CPU报警')
 11  
 12     if 硬盘使用空间 > 90%:
 13         发送邮件('硬盘报警')
 14  
 15     if 内存占用 > 80%:
 16         发送邮件('内存报警')

其实OOP编程的主要作用也是使你的代码修改和扩展变的更容易，那么小白要问了，既然函数都能实现这个需求了，还要OOP干毛线用呢？ 呵呵，说这话就像，古时候，人们打仗杀人都用刀，后来出来了枪，它的主要功能跟刀一样，也是杀人，然后小白就问，既然刀能杀人了，那还要枪干毛线，哈哈，显而易见，因为枪能更好更快更容易的杀人。函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改。

创建类和对象：

面向对象编程时变成的一种编程方式，此编程方式的落地需要使用“类”和“对象”来实现，所以，面向对象编程其实就是对“类”和“对象”的使用。

类就是一个模板，模板里可以包含多个函数，函数里面实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

271420286872390

  • class是关键字，表示类
  • 创建对象，类名称后加括号即可

ps：类中的函数第一个参数必须是self（详细见：类的三大特性之封装）
类中定义的函数叫做 “方法”

  1 # 创建类
  2 class Foo:
  3      
  4     def Bar(self):
  5         print 'Bar'
  6  
  7     def Hello(self, name):
  8         print 'i am %s' %name
  9  
 10 # 根据类Foo创建对象obj
 11 obj = Foo()
 12 obj.Bar()            #执行Bar方法
 13 obj.Hello('wupeiqi') #执行Hello方法　

诶，你在这里是不是有疑问了？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便

  • 面向对象：【创建对象】【通过对象执行方法】
  • 函数编程：【执行函数】

观察上述对比答案则是肯定的，然后并非绝对，场景的不同适合其的编程方式也不同。

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象三大特性：

面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

  • 将内容封装到某处
  • 从某处调用被封装的内容

第一步：将内容封装到某处

271641407509817

self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

271653303446704

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

  • 通过对象直接调用
  • 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

  1 class Foo:
  2  
  3     def __init__(self, name, age):
  4         self.name = name
  5         self.age = age
  6  
  7 obj1 = Foo('wupeiqi', 18)
  8 print obj1.name    # 直接调用obj1对象的name属性
  9 print obj1.age     # 直接调用obj1对象的age属性
 10  
 11 obj2 = Foo('alex', 73)
 12 print obj2.name    # 直接调用obj2对象的name属性
 13 print obj2.age     # 直接调用obj2对象的age属性

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

  1 class Foo:
  2   
  3     def __init__(self, name, age):
  4         self.name = name
  5         self.age = age
  6   
  7     def detail(self):
  8         print self.name
  9         print self.age
 10   
 11 obj1 = Foo('wupeiqi', 18)
 12 obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
 13   
 14 obj2 = Foo('alex', 73)
 15 obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
 16

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

二、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

例如：

猫可以：喵喵叫、吃、喝、拉、撒

狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，如下所示：

  1 
  2 class 猫：
  3 
  4     def 喵喵叫(self):
  5         print '喵喵叫'
  6 
  7     def 吃(self):
  8         # do something
  9 
 10     def 喝(self):
 11         # do something
 12 
 13     def 拉(self):
 14         # do something
 15 
 16     def 撒(self):
 17         # do something
 18 
 19 class 狗：
 20 
 21     def 汪汪叫(self):
 22         print '喵喵叫'
 23 
 24     def 吃(self):
 25         # do something
 26 
 27     def 喝(self):
 28         # do something
 29 
 30     def 拉(self):
 31         # do something
 32 
 33     def 撒(self):
 34         # do something
伪代码

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

动物：吃、喝、拉、撒

   猫：喵喵叫（猫继承动物的功能）

   狗：汪汪叫（狗继承动物的功能）

  1 class 动物:
  2 
  3     def 吃(self):
  4         # do something
  5 
  6     def 喝(self):
  7         # do something
  8 
  9     def 拉(self):
 10         # do something
 11 
 12     def 撒(self):
 13         # do something
 14 
 15 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 16 class 猫(动物)：
 17 
 18     def 喵喵叫(self):
 19         print '喵喵叫'
 20         
 21 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 22 class 狗(动物)：
 23 
 24     def 汪汪叫(self):
 25         print '喵喵叫'
伪代码
  1 class Animal:
  2 
  3     def eat(self):
  4         print "%s 吃 " %self.name
  5 
  6     def drink(self):
  7         print "%s 喝 " %self.name
  8 
  9     def shit(self):
 10         print "%s 拉 " %self.name
 11 
 12     def pee(self):
 13         print "%s 撒 " %self.name
 14 
 15 
 16 class Cat(Animal):
 17 
 18     def __init__(self, name):
 19         self.name = name
 20         self.breed ＝ '猫'
 21 
 22     def cry(self):
 23         print '喵喵叫'
 24 
 25 class Dog(Animal):
 26     
 27     def __init__(self, name):
 28         self.name = name
 29         self.breed ＝ '狗'
 30         
 31     def cry(self):
 32         print '汪汪叫'
 33         
 34 
 35 # ######### 执行 #########
 36 
 37 c1 = Cat('小白家的小黑猫')
 38 c1.eat()
 39 
 40 c2 = Cat('小黑的小白猫')
 41 c2.drink()
 42 
 43 d1 = Dog('胖子家的小瘦狗')
 44 d1.eat()
实例

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

272229566093488

学习了继承的写法之后，我们用代码来是上述阿猫阿狗的功能：

  1 
  2 class Animal:
  3 
  4     def eat(self):
  5         print "%s 吃 " %self.name
  6 
  7     def drink(self):
  8         print "%s 喝 " %self.name
  9 
 10     def shit(self):
 11         print "%s 拉 " %self.name
 12 
 13     def pee(self):
 14         print "%s 撒 " %self.name
 15 
 16 
 17 class Cat(Animal):
 18 
 19     def __init__(self, name):
 20         self.name = name
 21         self.breed ＝ '猫'
 22 
 23     def cry(self):
 24         print '喵喵叫'
 25 
 26 class Dog(Animal):
 27     
 28     def __init__(self, name):
 29         self.name = name
 30         self.breed ＝ '狗'
 31         
 32     def cry(self):
 33         print '汪汪叫'
 34         
 35 
 36 # ######### 执行 #########
 37 
 38 c1 = Cat('小白家的小黑猫')
 39 c1.eat()
 40 
 41 c2 = Cat('小黑的小白猫')
 42 c2.drink()
 43 
 44 d1 = Dog('胖子家的小瘦狗')
 45 d1.eat()
实例

那么问题又来了，多继承呢？

  • 是否可以继承多个类
  • 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

272315068126604

  • 当类是经典类时，多继承情况下，会按照深度优先方式查找
  • 当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

272341313127410

272341553282314

  1 class D:
  2 
  3     def bar(self):
  4         print 'D.bar'
  5 
  6 
  7 class C(D):
  8 
  9     def bar(self):
 10         print 'C.bar'
 11 
 12 
 13 class B(D):
 14 
 15     def bar(self):
 16         print 'B.bar'
 17 
 18 
 19 class A(B, C):
 20 
 21     def bar(self):
 22         print 'A.bar'
 23 
 24 a = A()
 25 # 执行bar方法时
 26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
 27 # 所以，查找顺序：A --> B --> D --> C
 28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
 29 a.bar()
经典类多继承
  1 class D(object):
  2 
  3     def bar(self):
  4         print 'D.bar'
  5 
  6 
  7 class C(D):
  8 
  9     def bar(self):
 10         print 'C.bar'
 11 
 12 
 13 class B(D):
 14 
 15     def bar(self):
 16         print 'B.bar'
 17 
 18 
 19 class A(B, C):
 20 
 21     def bar(self):
 22         print 'A.bar'
 23 
 24 a = A()
 25 # 执行bar方法时
 26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
 27 # 所以，查找顺序：A --> B --> C --> D
 28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
 29 a.bar()
新式类多继承

经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

三、多态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

  1 class F1:
  2     pass
  3 
  4 
  5 class S1(F1):
  6 
  7     def show(self):
  8         print 'S1.show'
  9 
 10 
 11 class S2(F1):
 12 
 13     def show(self):
 14         print 'S2.show'
 15 
 16 
 17 # 由于在Java或C#中定义函数参数时，必须指定参数的类型
 18 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
 19 # 而实际传入的参数是：S1对象和S2对象
 20 
 21 def Func(F1 obj):
 22     """Func函数需要接收一个F1类型或者F1子类的类型"""
 23     
 24     print obj.show()
 25     
 26 s1_obj = S1()
 27 Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
 28 
 29 s2_obj = S2()
 30 Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
python伪代码实现java或c#的多态
  1 class F1:
  2     pass
  3 
  4 
  5 class S1(F1):
  6 
  7     def show(self):
  8         print 'S1.show'
  9 
 10 
 11 class S2(F1):
 12 
 13     def show(self):
 14         print 'S2.show'
 15 
 16 def Func(obj):
 17     print obj.show()
 18 
 19 s1_obj = S1()
 20 Func(s1_obj) 
 21 
 22 s2_obj = S2()
 23 Func(s2_obj)
python“鸭子类型”

总结:

以上就是本节对于面向对象初级知识的介绍，总结如下：

  • 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
  • 类 是一个模板，模板中包装了多个“函数”供使用
  • 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
  • 面向对象三大特性：封装、继承和多态