面向对象完善总结

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

面向过程：根据业务逻辑从上到下写垒代码   面向过程的设计的核心是过程，过程即解决问题的步骤， 面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西   优点：极大降低了程序的复杂性   缺点：一套流水线或者流程就是用来解决一个问题，生产汽车的流水线无法生产汽水，即便是改造也要大改，牵一发而动全身。   函数式：将某功能代码封装到函数中，以后无需重复写代码，调用方便   面向对象：对函数进行分类和封装， "更快更好更强" 。   面向对象的程序核心是对象。如来安排唐僧，沙和尚，猪八戒，孙悟空去取经，但根本不会管师徒四人按照什么流程去取。   面向对象优点：解决了程序的可拓展性。对某一个对象单独修改会立刻反映到整个体系中，如对一个人物的参数的特征和技能修改都很容易。   面向对象缺点：可控性差，无法像面向过程的程序设计流水线式可以很精准的预测问题的处理流程和结果。   面向对象的程序一旦开始就由对象之间的交互解决问题，即使是上帝也无法预测最终结果。   面向对象应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。   面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

　　

 

创建类和对象

1 2 3 4 5

面向对象是一种编程方式，此编程方式需要‘类’和‘对象’来实现，所有面向对象编程实际就是对‘类’和‘对象’的使用。   类就是一个模板，模板里可以包含多个函数，函数里实现一些功能。   对象就是通过模板创建的实例，通过实例对象可以执行类中的函数。

　　

class是关键字，表示类

创建对象类后面加括号即可

类中的函数第一个参数必须是self，类中定义的函数叫做‘方法’。 

1 2 3 4 5 6 7 8 9 10 11 12

#创建类 class  foo:      def  bar( self ):          print ( 'bar' )      def  hello( self ,name):          print ( 'I am %s'  % name)     #根据类foo创建对象obj obj = foo() obj.bar()    #执行bar的方法 obj.hello( 'xuyaping' )    #执行hello的方法

面向对象：创建对象，通过对象执行方法。

函数编程：直接执行函数。

场景的不同适合其编程方式也不同。

函数式编程的应用场景---->各个函数之间是独立且无共用的数据。

 

 面向对象的三大特性：

 一、封装

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

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

1.将内容封装到某处；

2.从某处调用被封装的内容。

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

 

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

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

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

 

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12

class  foo:      def  __init__( self ,name,age):          self .name = name          self .age = age   obj1 = foo( 'xuyaping' , 18 ) print (obj1.name)       #直接调用obj1对象的name属性           print (obj1.age)         #直接调用obj1对象的age属性   obj2 = foo( 'alex' , 78 ) print (obj2.name)       #直接调用obj2对象的name属性 print (obj2.age)         #直接调用obj2对象的age属性

 

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class  foo:      def  __init__( self ,name,age):          self .name = name          self .age = age        def  detail( self ):          print ( self .name)          print ( self .age)   obj1 = foo( 'xuyaping' , 18 ) obj1.detail()     #python默认会将obj1传给self参数，即obj1.detail(obj1)，所以，此时方法内部的self=obj1，即self.name是xuyaping；self.age是18   obj2 = foo( 'alex' , 78 ) obj2.detail()     #python默认会将obj2传给self参数，即obj2.detail(obj2)，所以，此时方法内部的self=obj2，即self.name是alex；self.age是78

 

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

 

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#函数式编程 def  kanchai(name, age, gender):      print ( "%s,%s岁,%s,上山去砍柴"  % (name, age, gender))     def  qudongbei(name, age, gender):      print ( "%s,%s岁,%s,开车去东北"  % (name, age, gender))     def  dabaojian(name, age, gender):      print ( "%s,%s岁,%s,最爱大保健"  % (name, age, gender))     kanchai( '小明' ,  10 ,  '男' ) qudongbei( '小明' ,  10 ,  '男' ) dabaojian( '小明' ,  10 ,  '男' )     kanchai( '老李' ,  90 ,  '男' ) qudongbei( '老李' ,  90 ,  '男' ) dabaojian( '老李' ,  90 ,  '男' )

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

#面向对象编程 class  Foo:            def  __init__( self , name, age ,gender):          self .name  =  name          self .age  =  age          self .gender  =  gender        def  kanchai( self ):          print ( "%s,%s岁,%s,上山去砍柴"  % ( self .name,  self .age,  self .gender))        def  qudongbei( self ):          print ( "%s,%s岁,%s,开车去东北"  % ( self .name,  self .age,  self .gender))        def  dabaojian( self ):          print ( "%s,%s岁,%s,最爱大保健"  % ( self .name,  self .age,  self .gender))     xiaoming  =  Foo( '小明' ,  10 ,  '男' ) xiaoming.kanchai() xiaoming.qudongbei() xiaoming.dabaojian()   laoli  =  Foo( '老李' ,  90 ,  '男' ) laoli.kanchai() laoli.qudongbei() laoli.dabaojian()

 

上述对比可以看出，使用函数式编程需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了...；而使用面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，需要通过self间接去当前对象中取值即可。

 

二、继承

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#伪代码 class  猫：        def  喵喵叫( self ):          print ( '喵喵叫' )        def  吃( self ):          # do something        def  喝( self ):          # do something        def  拉( self ):          # do something        def  撒( self ):          # do something   class  狗：        def  汪汪叫( self ):          print ( '喵喵叫' )        def  吃( self ):          # do something        def  喝( self ):          # do something        def  拉( self ):          # do something        def  撒( self ):          # do something

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

动物：吃、喝、拉、撒

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#伪代码 class  动物:        def  吃( self ):          # do something        def  喝( self ):          # do something        def  拉( self ):          # do something        def  撒( self ):          # do something   # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class  猫(动物)：        def  喵喵叫( self ):          print ( '喵喵叫' )           # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class  狗(动物)：        def  汪汪叫( self ):          print ( '喵喵叫' )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#代码如下： class  Animal:        def  eat( self ):          print ( "%s 吃 "  % self .name)        def  drink( self ):          print ( "%s 喝 "  % self .name)        def  shit( self ):          print ( "%s 拉 "  % self .name)        def  pee( self ):          print ( "%s 撒 "  % self .name)     class  Cat(Animal):        def  __init__( self , name):          self .name  =  name          self .breed＝ '猫'        def  cry( self ):          print ( '喵喵叫' )   class  Dog(Animal):            def  __init__( self , name):          self .name  =  name          self .breed＝ '狗'                def  cry( self ):          print ( '汪汪叫' )             # ######### 执行 #########   c1  =  Cat( '小白家的小黑猫' ) c1.eat()   c2  =  Cat( '小黑的小白猫' ) c2.drink()   d1  =  Dog( '胖子家的小瘦狗' ) d1.eat()

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

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

 

多继承　　

是否可以继承多个类？

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

1.python的类可以继承多个类，java和C#中则只能继承一个类

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

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

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

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

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

#经典类多继承 class  D:        def  bar( self ):          print ( 'D.bar' )     class  C(D):        def  bar( self ):          print ( 'C.bar' )     class  B(D):        def  bar( self ):          print ( 'B.bar' )     class  A(B, C):        def  bar( self ):          print ( 'A.bar' )   a  =  A() # 执行bar方法时 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> D --> C # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar()

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

#新式类多继承 class  D( object ):        def  bar( self ):          print ( 'D.bar' )     class  C(D):        def  bar( self ):          print ( 'C.bar' )     class  B(D):        def  bar( self ):          print ( 'B.bar' )     class  A(B, C):        def  bar( self ):          print ( 'A.bar' )   a  =  A() # 执行bar方法时 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> C --> D # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar()

　　  

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

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

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

python3中统一都是新式类

python2中才分新式类和经典类

 

 三、多态

python不支持java和C#这一类强类型语言中多态的写法，但是原生多态python崇尚‘鸭子类型’。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

#Python伪代码实现Java或C#的多态 class  F1:      pass     class  S1(F1):        def  show( self ):          print ( 'S1.show' )     class  S2(F1):        def  show( self ):          print ( 'S2.show' )     # 由于在Java或C#中定义函数参数时，必须指定参数的类型 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类 # 而实际传入的参数是：S1对象和S2对象   def  Func(F1 obj):      """Func函数需要接收一个F1类型或者F1子类的类型"""            print (obj.show())       s1_obj  =  S1() Func(s1_obj)  # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show   s2_obj  =  S2() Func(s2_obj)  # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#Python “鸭子类型” class  F1:      pass     class  S1(F1):        def  show( self ):          print ( 'S1.show' )     class  S2(F1):        def  show( self ):          print ( 'S2.show' )   def  Func(obj):      print (obj.show())   s1_obj  =  S1() Func(s1_obj)   s2_obj  =  S2() Func(s2_obj)

 

总结：

1.面向对象是一种编程方式，此编程方式的实现是基于对类和对象的使用；

2.类是一个模板，模板中包装了多个‘函数’供使用；

3.对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数；

4.面向对象三大特性：封装、继承和多态。

问答专区

问题一：什么样的代码才是面向对象？

从简单来说，如果程序中所有功能都是用类和对象来实现，那么就是面向对象编程了。

问题二：函数式编程和面向对象如何选择？分别在什么情况下使用？

对于java和C#程序员来说不存在这个问题，因为这二门语言只支持面向对象编程，不支持函数式编程。而对于python和php等语言却同时支持二种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的编程能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。

所以，一般在python开发中，全部使用面向对象或面向对象和函数式编程混合使用。

面向对象的应用场景：

1.多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码。

 1 class SqlHelper:
 2 
 3     def __init__(self, host, user, pwd):
 4 
 5         self.host = host
 6         self.user = user
 7         self.pwd = pwd
 8 
 9     def 增(self):
10         # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
11         # do something
12         # 关闭数据库连接
13 
14     def 删(self):
15         # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
16         # do something
17         # 关闭数据库连接
18 
19     def 改(self):
20         # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
21         # do something
22         # 关闭数据库连接
23 
24     def 查(self):
25     # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
26         # do something
27         # 关闭数据库连接# do something

2.需要创建多个事物，每个事物属性个数相同，但是值的需求如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同。

 1 class Person:
 2 
 3     def __init__(self, name ,age ,blood_type):
 4 
 5         self.name = name
 6         self.age = age
 7         self.blood_type = blood_type
 8 
 9 
10     def detail(self):
11         temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
12         print temp
13 
14 zhangsan = Person('张三', 18, 'A')
15 lisi = Person('李四', 73, 'AB')
16 yangwu = Person('杨五', 84, 'A')

 

 问题三：类和对象在内存中是如何保存？

类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份，大致如下图：

 

如上图所示，根据类创建对象时，对象中除了封装name和age的值外，还会保存一个类对象指针，该指针指向当前对象的类。

当通过obj1执行“方法一”时，过程如下：

1.根据当前对象的类对象指针找到类中的方法。

2.将对象obj1当中参数传给方法的第一个参数self。 

转载于:https://www.cnblogs.com/gpd-Amos/p/7880914.html