python面向对象（封装、继承、多态）+ 面向对象小栗子

　　大家好，下面我说一下我对面向对象的理解，不会讲的很详细，因为有很多人的博客都把他写的很详细了，所以，我尽可能简单的通过一些代码让初学者可以理解面向对象及他的三个要素。

 

摘要：
1、首先介绍一下面向对象
2、然后分别讲一下封装、继承和多态
3、最后通过一段面向对象的案例来更好的理解一下面向对象

　　

　　python是一门面向对象编程语言，对面相对象语言编码的过程叫做面向对象编程。

　　面向对象时一种思想，与之相对对的是面向过程。我们先简单说一下面向过程。

　　面向过程其实就是把过程当做设计核心，根据问题的发展顺序，依次解决问题，尽可能的把过程中涉及到的问题完善解决。他有他的优点，当拿到一个问题时，可以方便的按执行的步骤写代码，但是当逻辑关系变得复杂时，有一个地方出现差错就会导致整个程序无从下手。

　　既然主要是说python，那我们还是回来说说python的面向对象，面向对象的编程语言还是很多的，例如C++、Java等等。

　　面向对象程序设计把计算机程序的执行看做一组对象的集合，每个对象之间进行消息的传送处理。有一个显著的优点就是，对某个对象进行修改，整个程序不会受到影响，自定义数据类型就是面向对象中的类的概念，而我们需要把他们的接口处理好就很好办了。说了这么多话，有些小白已经看不下去了，那接下来我们进入主题。

• 上面说了，自定义数据类型就是面向对象中的类的概念。我们先介绍一下待会儿会用到的一些术语：

 1 # 我认为还是通过个例子更容易让人理解
 2 
 3 # 首先我们定义一个类
 4 class A(object):    # 这是一个类，class是创建一个类的标志 
 5     # 类变量（类属性）：类属性是指类的属性，属性就是我们刚学编程的时候听过的变量。
 6     x = 7
 7     y = "asdf"
 8     
 9     def __init__(self,name,age):
10         self.name = name
11         self.age = age
12 
13     # 方法：方法就是在类外面我们写的函数，放在类里就叫做一个方法
14     def func(self):
15         c = 8    # 实例变量：定义在方法中的变量只作用于当前实例的类
16         print("Hello World!")
17 
18 a = A()    # 创建一个对象，实例化

　　上面的部分代码还需要再解释一下：

• object：
  • 注意类名后面括号里有个参数object，他代表所有类的基类，也叫作超类。
  • 这就有了一个新式类和旧式类的概念：
  • 当用到多继承的时候，如果子类中没有想用的方法名或属性名，他会自动回到上面去找。那么按广度优先遍历的方法去寻找就是新式类（object）；深度优先（括号里啥也没有）。
• __init__()：构造函数，实例化的时候若不显示的定义，那么默认调用一个无参的，是初始化的意思。

 

一、封装

　　含义：对外面隐藏对象的属性和方法，仅提供接口。

　　作用：安全性（通过私有变量改变对外的使用），复用性

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Student(object):
 5     def __init__(self, name, score):
 6         # 属性仅前面有两个下划线代表私有变量，外部无法访问，因此我们定义了两个新的方法，这样可以避免外部通过score乱改分数，仅当我们自己知道接口才可以修改
 7         self.__name = name
 8         self.__score = score
 9 
10     def info(self):
11         print('name: %s ; score: %d' % (self.__name,self.__score))
12 
13     def getScore(self):
14         return self.__score
15 
16     def setScore(self, score):
17         self.__score = score
18 
19 stu = Student('Tom',99)
20 print('修改前分数：',stu.getScore())
21 stu.info()
22 stu.setScore(59)
23 print('修改后分数：',stu.getScore())
24 stu.info()

　　封装还是比较好理解的，不过其中还有一些，比如析构函数，重写等等知识点最好在官方文档过一遍。

 

二、继承

　　2.1.1、含义

　　前面我们提到过，面向对象编程有个好处就是代码复用，而其中一种方法就是通过继承机制。继承就是说定义的一个新类，继承现有的类，获得现有类的非私有属性、方法。提到个私有，就是上面提到的那个前面加两个下划线的那个东西，他在外部无法调用，继承他的子类也不能。被继承的那个类称为基类、父类或超类，子类也可以叫做派生类。

　　2.1.2、特点

　　　　1、在继承中，基类的构造方法（__init__()方法）不会被自动调用，需要在子类的构造方法中专门调用。

　　　　2、在调用基类的方法时需要加上基类的类名前缀，并带上self参数变量。区别于在类中调用普通函数时不需要带self参数。

　　　　3、在python中，首先查找对应类型的方法，如果在子类中找不到对应的方法，才到基类中逐个查找。

　　2.2、单继承

　　　　直接上代码，仔细理解一下里面的关系，我把讲解都写在注释的地方。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 # 这是定义了一个基类
 5 class Person(object):
 6     def __init__(self, name, age, money):
 7         self.name = name
 8         self.age = age
 9         self.__money = money # 私有属性
10         # 被引入时，继承不了，但他们的set，get函数可以继承
11 
12     def setMoney(self,money):
13         self.__money = money
14 
15     def getMoney(self):
16         return self.__money
17 
18     def run(self):
19         print("run")
20 
21     def eat(self):
22         print("eat")

　　下面是定义的一个子类，继承自上方的类，来使用父类中的方法和属性：

1 # 由于我将每个类写在了不同的文件里，所以需要引入一下，这就和我们调用库一样
2 from 单继承的实现.person import Person
3 
4 class Student(Person):
5     def __init__(self,name,age,stuid,money):
6         # 调用父类中的__init__()，supper括号中的内容，在python3以后可以不写，写上更安全些
7         super(Student,self).__init__(name,age,money) # 让父类的self当做子类的对象
8         # 子类可以由一些自己独有的属性或者方法
9         self.stuid = stuid

　　 创建对象，通过子类使用父类的属性和方法：

1 from 单继承的实现.student import Student
2 
3 stu = Student('Tom',18,111,999) # 创建Student对象
4 # 下列方法和属性均是在父类Person中定义的，在Student继承之后，便可以直接使用
5 print(stu.name, stu.age)
6 stu.run()
7 print(stu.getMoney())

　　2.3、多继承

　　上面的单继承要多理解一下，单继承理解了之后，多继承也就没什么了。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Father(object):
 5     def __init__(self,money):
 6         self.money = money
 7     def play(self):
 8         print("play")
 9     def func(self):
10         print("func1")
11 
12 class Mother(object):
13     def __init__(self,facevalue):
14         self.facevalue = facevalue
15     def eat(self):
16         print("eat")
17     def func(self):
18         print("func2")
19 
20 
21 class Children(Father,Mother):
22     def __init__(self,money,facevalue):
23         # 多继承时调用父类的属性
24         Father.__init__(self,money)
25         Mother.__init__(self,facevalue)
26 
27 def main():
28     c = Children(300,100)
29     print(c.money,c.facevalue)
30     c.play()
31     c.eat()
32     # 注意：如果多个父类中有相同的方法名，默认调用括号中前面的类
33     c.func()
34 if __name__ == "__main__":
35     main()

View Code

三、多态

• 多态：是指一种事物的多种形态
• 多态性：多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
• eg：在python中的“+”号，它既可以表示数字的加法，也可以表示字符串的拼接，（__add__()）

 1 class Animal(object):
 2     def __init__(self, name):
 3         self.name = name
 4 
 5     def run(self):
 6         pass
 7 
 8     def animalRun(self):
 9         self.run()
10 
11 
12 class Cat(Animal):
13     def run(self):
14         print('cat is running')
15 
16 
17 class Dog(Animal):
18     def run(self):
19         print('dog is running')
20 
21 
22 d = Dog('dog')
23 c = Cat('cat')
24 
25 Animal.animalRun(c)
26 Animal.animalRun(d)

View Code

 

四、面向对象案例

　　下面给一个小程序，是模拟反恐精英，保卫者和敌人。主要是让大家看明白，只有简单的几个功能，希望大家可以从中理解面向对象的思想。python中，任何都是对象。

　　　　　　　　　　　　　　　　　　

　　首先，这是我的几个类模块，分开来写比较清晰一点，写在一起也是没问题的。接下来我们一点一点的分析：

　　。。。。。。。。。。

　　得有人，好人和坏人

　　。。。。。。。。。。

　　人得有武器，先给他们两种：枪和手榴弹

　　。。。。。。。。。。

　　枪还有个弹夹也可以作为对象

　　。。。。。。。。。。

　　想想还有什么，差不多了吧，那么我们就开始写，想到什么再补充

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.person import Person
 5 
 6 class Gengster(Person):
 7 
 8     # 初始化，血量默认为100
 9     def __init__(self, gun, grenade, blood=100):
10         self.gun = gun
11         self.grenade = grenade
12         self.blood = blood
13 
14     # 人有开枪的功能
15     def fire(self,person):
16         person.blood.amount -= 5 # 对谁开枪，那个人就要减血
17         self.gun.shoot() # 这个人开枪，这又调用了枪的类，关于子弹的减少在枪的类里
18 
19     # 扔手榴弹，实际上是和枪一样的
20     def fire2(self,person):
21         person.blood -= 10
22         self.grenade.damage() # 同样通过另一个类来控制数量的减少，使代码看起来简洁点
23 
24     # 给弹夹里加子弹
25     def fillbullet(self):
26         self.gun.bulletbox.bulletcount += 10
27 
28     # 补血，并保证满血只能是100
29     def fillblood(self,num):
30         self.blood += num
31         if self.blood > 100:
32             self.blood = 100
33         print("补血后血量：" + str(self.blood))

坏蛋

 1 # 主要注释和上一个类似，这里不赘述
 2 
 3 #!/usr/bin/env python
 4 # -*- coding:utf-8 -*-
 5 
 6 from cs.person import Person
 7 
 8 class Profector(Person):
 9 
10     def __init__(self, gun, grenade, blood = 100):
11         self.gun = gun
12         self.grenade = grenade
13         self.blood = blood
14 
15     def fire(self, person):
16         person.blood -= 5
17         self.gun.shoot()
18         print(str(person) + "血量减少5，剩余" + str(person.blood) )
19 
20     def fire2(self,person):
21         person.blood -= 10
22         self.grenade.damage()
23 
24     def fillbullet(self):
25         self.gun.bulletbox.bulletcount += 10
26 
27     def fillblood(self,num):
28         self.blood += num
29         if self.blood > 100:
30             self.blood = 100
31         print("补血后血量：" + str(self.blood))

好人

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Gun(object):
 5 
 6     # 初始化，把弹夹放里面，通过人来控制枪，再来控制弹夹
 7     def __init__(self,bulletbox):
 8         self.bulletbox = bulletbox
 9 
10     def shoot(self):
11         if self.bulletbox.bulletcount == 0:
12             print('没子弹了')
13         else:
14             self.bulletbox.bulletcount -= 1
15             print(str(self) + '开一枪，还剩%d颗子弹' % (self.bulletbox.bulletcount))

枪

 1 # 与枪类似
 2 
 3 #!/usr/bin/env python
 4 # -*- coding:utf-8 -*-
 5 
 6 class Grenade(object):
 7 
 8     def __init__(self,grenadecount):
 9         self.grenadecount = grenadecount
10 
11     def damage(self):
12         if self.grenadecount == 0:
13             print('手雷没有了')
14         else:
15             self.grenadecount -= 1
16             print(str(self) + "轰他一炮，手雷还剩%d颗" % (self.grenadecount))

手榴弹

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 class Bulletbox(object):
5 
6     # 弹夹只需控制数量就好了
7     def __init__(self,bulletcount):
8         self.bulletcount = bulletcount

弹夹

　　这下差不多了，人也有了，武器也有了，可以开展了

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.grenade import Grenade
 5 from cs.gun import Gun
 6 from cs.bulletbox import Bulletbox
 7 from cs.gengster import Gengster
 8 from cs.profector import Profector
 9 # 参数：枪，手榴弹，血（默认100，且上限为100）
10 
11 # 创建弹夹，枪，手榴弹的对象，以备人使用
12 bulletbox = Bulletbox(10)
13 gun = Gun(bulletbox)
14 grenade = Grenade(20)
15 
16 # 创建人对象
17 good1 = Profector(gun,grenade)
18 good2 = Profector(gun,grenade)
19 bad1 = Gengster(gun,grenade)
20 bad2 = Gengster(gun,grenade)
21 
22 print("好人1开枪打坏人1和2")
23 good1.fire(bad1)
24 good1.fire(bad2)
25 print("好人2开枪打坏人1和2")
26 good2.fire(bad1)
27 good2.fire(bad2)
28 print("坏人1炸好人1和2")
29 bad1.fire2(good1)
30 bad1.fire2(good2)
31 print("坏人2炸好人1和2")
32 bad2.fire2(good1)
33 bad2.fire2(good2)
34 print("坏人1补血3个")
35 bad1.fillblood(3)

main

　　现在这一套流程就结束了，刚开始看也许看不太懂，要仔细看一下每个类之间的关系，先想清楚了，再来看代码是如何实现的

　　有没有看出来点区别，面向过程编程是就事论事，而面向对象，先把对象找出来，通过对象之间的关系把他们联系起来。想想如果要用面向过程来实现这个，代码会写成什么样子呢。

　　然而并没有结束，记不记得前面的类中有两对是比较类似的，好人和坏人，枪和手榴弹（这个里面的类还不太一样），那么想到了什么没有，前面提到的继承的优点是什么来着，----复用。我们可以可以用继承来写一下呢，如果你说这个也没少几行代码嘛，那么，如果在实际当中你要创建成百上千的对象呢，难道还要每个都复制粘贴改代码吗，还占空间对不对。

　　那么我们写一个人类，毕竟好人和坏人都是人：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Person(object):
 5 
 6     def __init__(self, gun, grenade, blood):
 7         self.gun = gun
 8         self.grenade = grenade
 9         self.blood = blood
10 
11     def fire(self, person):
12         person.blood -= 5
13         self.gun.shoot()
14         print(str(person) + "血量减少5，剩余" + str(person.blood) )
15 
16     def fire2(self, person):
17         person.blood -= 10
18         self.grenade.damage()
19         print(str(person) + "血量减少10，剩余" + str(person.blood) )
20 
21     def fillbullet(self):
22         self.gun.bulletbox.bulletcount += 10
23 
24     def fillblood(self,num):
25         self.blood += num
26         if self.blood > 100:
27             self.blood = 100
28         print(str(self) + "补血后血量：" + str(self.blood))

person

　　现在我们就不必把好人坏人都重写了，只需要继承一下人类就好了：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.person import Person
 5 
 6 class Profector(Person):
 7 
 8     def __init__(self, gun, grenade, blood = 100):
 9         super(Profector,self).__init__(gun, grenade, blood)
10 
11 
12 class Gengster(Person):
13 
14     def __init__(self, gun, grenade, blood=100):
15         super(Gengster, self).__init__(gun, grenade, blood)
16 
17 # 这里面有个supper，他就是对父类的继承

好人和坏人

　　我知道大家看的有点迷了，我把他整在一起了，不过还是建议大家先根据每个小模块学习，顺便理解一下引入自定义模块。下面是完整代码，可以直接粘贴：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Bulletbox(object):
 5     def __init__(self,bulletcount):
 6         self.bulletcount = bulletcount
 7 
 8 
 9 class Gun(object):
10     def __init__(self,bulletbox):
11         self.bulletbox = bulletbox
12 
13     def shoot(self):
14         if self.bulletbox.bulletcount == 0:
15             print('没子弹了')
16         else:
17             self.bulletbox.bulletcount -= 1
18             print(str(self) + '开一枪，还剩%d颗子弹' % (self.bulletbox.bulletcount))
19 
20 
21 class Grenade(object):
22     def __init__(self,grenadecount):
23         self.grenadecount = grenadecount
24 
25     def damage(self):
26         if self.grenadecount == 0:
27             print('手雷没有了')
28         else:
29             self.grenadecount -= 1
30             print(str(self) + "轰他一炮，手雷还剩%d颗" % (self.grenadecount))
31 
32 
33 class Person(object):
34     def __init__(self, gun, grenade, blood):
35         self.gun = gun
36         self.grenade = grenade
37         self.blood = blood
38 
39     def fire(self, person):
40         person.blood -= 5
41         self.gun.shoot()
42         print(str(person) + "血量减少5，剩余" + str(person.blood) )
43 
44     def fire2(self, person):
45         person.blood -= 10
46         self.grenade.damage()
47         print(str(person) + "血量减少10，剩余" + str(person.blood) )
48 
49     def fillbullet(self):
50         self.gun.bulletbox.bulletcount += 10
51 
52     def fillblood(self,num):
53         self.blood += num
54         if self.blood > 100:
55             self.blood = 100
56         print(str(self) + "补血后血量：" + str(self.blood))
57 
58 
59 class Profector(Person):
60     def __init__(self, gun, grenade, blood = 100):
61         super(Profector,self).__init__(gun, grenade, blood)
62 
63 
64 class Gengster(Person):
65     def __init__(self, gun, grenade, blood=100):
66         super(Gengster, self).__init__(gun, grenade, blood)
67 
68 
69 bulletbox = Bulletbox(10)
70 gun = Gun(bulletbox)
71 grenade = Grenade(20)
72 
73 good1 = Profector(gun,grenade)
74 good2 = Profector(gun,grenade)
75 bad1 = Gengster(gun,grenade)
76 bad2 = Gengster(gun,grenade)
77 
78 print("好人1开枪打坏人1和2")
79 good1.fire(bad1)
80 good1.fire(bad2)
81 print("好人2开枪打坏人1和2")
82 good2.fire(bad1)
83 good2.fire(bad2)
84 print("坏人1炸好人1和2")
85 bad1.fire2(good1)
86 bad1.fire2(good2)
87 print("坏人2炸好人1和2")
88 bad2.fire2(good1)
89 bad2.fire2(good2)
90 print("坏人1补血3个")
91 bad1.fillblood(3)

all

　　我在这里还想和大家一起看一下结果：

　　看一下有没有发现什么问题呢？

　　血量减少的人的对象还是正常的，然而看一下开枪的人。有没有发现好人1和好人2的对象时同一个地址呢，他们的子弹也是累积的递减；坏人使用手榴弹也是。为什么开枪的人会是这样，而受伤的人却是正常的呢？

　　提醒一下，我们前面创建的那些对象，有些是为了下一个对象调用而准备的，看看出错是在那个模块里错的，出错的和正确的他们之间有哪些不一样呢，而且出错的原理是什么呢？大家可以思考思考，评论区互相讨论一下。

　　

　　今天就到这里了，大家多多互动，互相学习。希望路过的大佬指点指点。