面向对象基础篇

1、面向对象和函数的区别面向过程:根据业务逻辑从上到下写垒代码函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可面向对象:对函数进行分类和封

1、面向对象和函数的区别

  面向过程:根据业务逻辑从上到下写垒代码

  函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

  面向对象:对函数进行分类和封装,让开发“更快更好更强

2、面向对象是一种编程方式,此编程方式一般使用“类”和“对象”来实现,所以面向对象编程就是对类和对象的使用。

类就是一个模板,模板里面包含很多函数,在函数中实现一些功能。

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

1 class foo(object):     #class是关键字,表示要创建类,foo是类的名称。
2     def bar(self):       #创建类中的函数
3         print("he is jason")    #
4 
5 obj = foo()    #根据类foo创建对象
6 obj.bar()      #传参数

备注:类中函数的第一个参数必须是self,表示类中的对象。类中定义的函数叫做方法。

简单类的创建及其方法的调用等

 1 class foo:   #创建类
 2     def bar(self):
 3         print("i am bar")
 4 
 5     def hello(self,name):
 6         print("i am %s" %name)
 7 
 8 obj = foo()     #根据类foo创建对象obj
 9 obj.bar()       #执行bar方法
10 obj.hello("wupeiqi")    #执行hello方法

3、面向对象的三大特性

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

一、封装:封装就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以在使用面向对象封装特性时,需要:

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

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

 1 class foo(object):   #创建类
 2 
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6 
 7 
 8 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
 9 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
10 
11 print(obj1.name,obj1.age)   #打印obj1的名字和年龄
12 print(obj2.name,obj2.age)   #打印obj2的名字和年龄

self 是一个形式参数,当执行obj1 = foo("haha",20)时,self ==obj1

          当执行obj2 = foo(“hehe”,21)时,self == obj2

所以,内容被封装到了对象obj1和obj2中,每个对象中都有name和age属性。

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

调用被封装的内容时,有两种情况:

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

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

 1 class foo(object):   #创建类
 2 
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6 
 7 
 8 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
 9 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
10 
11 print(obj1.name)   #直接调用obj1对象的name属性
12 print(obj1.age)    #直接调用obj1对象的age属性
13 print(obj2.name)   #直接调用obj2对象的name属性
14 print(obj2.age)    #直接调用boj2对象的age属性

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

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

 1 class foo(object):   #创建类
 2 
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6     def detail(self):
 7         print(self.name)
 8         print(self.age)
 9 
10 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
11 obj1.detail()
12 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
13 obj2.detail()

如上所示:python首先执行init函数,把obj 传给self。并通过detail函数打印出结果

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

封装的练习

练习一:在终端输出如下信息

  • 小明,10岁,男,上山去砍柴
  • 小明,10岁,男,开车去东北
  • 小明,10岁,男,最爱大保健
  • 老李,90岁,男,上山去砍柴
  • 老李,90岁,男,开车去东北
  • 老李,90岁,男,最爱大保健
  • 老张...

面向对象实现一

 1 class foo(object):   #创建类
 2 
 3     def __init__(self,name,age,gender,profession):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7         self.profession = profession
 8 
 9 
10 obj1 = foo("小明",10,"","上山去砍柴")
11 
12 obj2 = foo("小明",10,"","开车去东北")
13 
14 obj3 = foo("小明",10,"","最爱大保健")
15 obj4 = foo("老李",90,"","上山去砍柴")
16 obj5 = foo("老李",90,"","开车去东北")
17 obj6 = foo("老李",90,"","最爱大保健")
18 
19 print obj1.name,obj1.age,obj1.gender,obj1.profession
20 print obj2.name,obj2.age,obj2.gender,obj2.profession
21 print obj3.name,obj3.age,obj3.gender,obj3.profession
22 print obj4.name,obj4.age,obj4.gender,obj4.profession
23 print obj5.name,obj5.age,obj5.gender,obj5.profession
24 print obj6.name,obj6.age,obj6.gender,obj6.profession
面向对象实现一

面向对象实现二:

 1 class foo(object):   #创建类
 2 
 3     def __init__(self,name,age,gender):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7     def kanchai(self):
 8         print "%s,%s岁,%s,上山去砍柴" %(self.name,self.age,self.gender)
 9     def qudongbei(self):
10         print "%s,%s,%s,开车去东北" %(self.name,self.age,self.gender)
11     def dabaojian(self):
12         print "%s,%s,%s,最爱大保健" %(self.name,self.age,self.gender)
13 
14 obj = foo("小明",10,"")
15 obj.kanchai()
16 obj.qudongbei()
17 obj.dabaojian()
18 
19 laoli = foo("老李",90,'')
20 laoli.kanchai()
21 laoli.qudongbei()
22 laoli.dabaojian()
面向对象实现二

函数实现方法:

 1 def kanchai(name,age,gender):
 2     print "%s,%s岁,%s,上山去砍柴" %(name,age,gender)
 3 def qudongbei(name,age,gender):
 4     print "%s,%s岁,%s,开车去东北" %(name,age,gender)
 5 def dabaojian(name,age,gender):
 6     print "%s,%s岁,%s,最爱大保健" %(name,age,gender)
 7 
 8 kanchai("小明",10,"")
 9 qudongbei("小明",10,"")
10 dabaojian("小明",10,"")
11 
12 kanchai("老李",10,"")
13 qudongbei("老李",10,"")
14 dabaojian("老李",10,"")
函数实现

 封装的练习二:游戏人生程序

1、创建三个游戏人物,分别是:

  • 苍井井,女,18,初始战斗力1000
  • 东尼木木,男,20,初始战斗力1800
  • 波多多,女,19,初始战斗力2500

2、游戏场景,分别:

  • 草丛战斗,消耗200战斗力
  • 自我修炼,增长100战斗力
  • 多人游戏,消耗500战斗力

代码实现如下:

 1 class game(object):
 2     def __init__(self,name,gender,age,fight):
 3         self.name = name
 4         self.gender = gender
 5         self.age = age
 6         self.fight = fight
 7 
 8     def caocong(self):
 9         print self.fight - 200
10     def xiulian(self):
11         print self.fight +100
12     def youxi(self):
13         print self.fight - 500
14     def detail(self):
15         temp = "姓名:%s;性别:%s;年龄:%s;战斗力:%s" %(self.name,self.gender,self.age,self.fight)
16         print temp
17 
18 cang = game("仓京京","",18,1000)
19 dong = game("东尼木木","",20,1800)
20 bo = game("波多多","",19,2500)
21 
22 cang.caocong()
23 dong.xiulian()
24 bo.youxi()
25 
26 cang.detail()
27 dong.detail()
28 bo.detail()

 

4、继承

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

例如:猫可以   叫、吃、喝、拉

     狗可以,叫、吃、和、拉

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

 1 class cat:
 2     def catcall(self):
 3         print "call"
 4     def eat(self):
 5         print "eat"
 6     def drunk(self):
 7         print "drunk"
 8     def shit(self):
 9         print "shit"
10 class dog:
11     def dogcall(self):
12         print "call"
13     def eat(self):
14         print "eat"
15     def drunk(self):
16         print "drunk"
17     def shit(self):
18         print "shit"

上述代码可以看出,吃、喝拉都屎猫和狗具有的共同功能,我们分别为狗和猫的类中写了两次。如果使用继承的思想,如下实现:

动物:吃、喝、拉

  猫:猫叫(猫继承动物的功能)

  狗:狗叫(狗继承动物的功能)

 1 class animal:
 2     def eat(self):
 3         print "%s 吃" %self.name
 4     def drunk(self):
 5         print "%s 喝" %self.name
 6     def shit(self):
 7         print "%s 拉" %self.name
 8 class cat(animal):
 9     def __init__(self,name):
10         self.name = name
11         self.breed = ""
12     def cry(self):
13         print "猫叫"
14 class dog(animal):
15     def __init__(self,name):
16         self.name = name
17         self.breed = ""
18     def cry(self):
19         print "狗叫"
20 
21 c1 = cat("A小猫")
22 c1.eat()
23 
24 c2 = cat("B小猫")
25 c2.drunk()
26 d1 = dog("A狗")
27 d1.eat()
28 
29 ————————————————————————————————————
30 
31 打印结果:
32 A小猫 吃
33 B小猫 喝
34 A狗 吃

对于面向对象的继承来说,就是将多个类共有的方法提取到父类中,子类仅需继承父类,而不再一一写下此功能,统一在父类中实现即可。