day6-面向对象知识补充

一、什么是面向对象？

在学面向对象之前我们都是用：函数

面向对象编程其实就是：类 + 对象

二、什么是类，什么是对象，它们之间又有什么关系？

 1 class 类名：
 2 
 3     def 函数1():
 4         pass
 5  
 6     def 函数2():
 7         pass
 8 
 9 # obj是实例化对象
10 obj = 类名()
11 obj.函数1()

三、使用场景

1. 提取公共功能

 1 class SSH:
 2     def __init__(self, host,port,pwd,username):
 3         self.host =
 4         ...
 5 
 6     def connection(self):
 7         # 去创建连接
 8         self.conn = 和服务器创建的连接对象()
 9 
10     def close(self):
11         # 关闭
12         self.conn.关闭
13 
14     def upload(self):
15         self.conn 使用连接上传文件
16 
17     def cmd(self):
18         self.conn 使用连接执行命令
19 
20 obj = SSH(....)
21 obj.connection()
22 obj.upload()
23 obj.close()

2. 根据一个模版创建某些东西

3. 多个函数传入共同参数

 1 class f:
 2      
 3     def __init__(self,host,port,pwd,arg):
 4             self.host = host
 5             self.port = port
 6             self.pwd = pwd
 7             self.arg = arg
 8          
 9     def f2(self):
10             self.host
11              ....
12  
13     def f2(self,args2):
14             self.host
15             ....
16      
17     def f3(self,args3):
18             self.host
19             ....

四、self

self就是调用当前方法的对象

 1 class Foo:
 2     # 静态字段，每个对象中保存相同的东西时，可以使用静态字段
 3     # 公有属性
 4     country = "中国"
 5 
 6     def __init__(self, name,count):
 7         # 普通字段
 8         # 普通属性
 9         self.NAME = name
10         self.Count = count
11 
12     def bar(self):
13         pass
14 
15 obj1 = Foo('河南', 1000000)
16 obj1.bar()
17 
18 obj2 = Foo('山东', 10000)
19 obj2.bar()

五、封装、继承、多态

封装

类中封装（保存在类中） ：静态字段、普通方法、静态方法

对象中封装（保存在对象中）：普通字段的值

不仅可以封装字段，还可以封装对象

 1 class F1:
 2     
 3     def __init__(self,n):
 4         self.N = n
 5         print('F1')
 6         
 7     # 普通方法，保存在类中，调用者对象，至少有self参数
 8     def a1(self):
 9         print(self.N)
10 
11     # 静态方法，保存在类中，调用者类（无需创建对象），可以有任意个参数
12     @staticmethod
13     def a2(b1,b2):
14         print('alex',b1,b2)
15     
16 
17 class F2:
18     def __init__(self,arg1):
19         self.a = arg1
20         print('F2')
21 
22 class F3:
23     def __init__(self,arg2):
24         self.b = arg2
25         print('F3')
26 
27 o1 = F1('alex')
28 o2 = F2(o1)
29 o3 = F3(o2)
30 
31 # 怎么输出alex?
32 # o3 = F3(o2) ==> F3(o3, o2) ==> o3.b = o2
33 # o2 = F2(o1) ==> F2(o2, o1) ==> o2.a = o1 ==> o3.b.a = o1
34 # o1 = F1('alex') ==> F1(o1, 'alex') ==> o1.N = 'alex' ==> o3.b.a.N = 'alex'
35 
36 print(o3.b.a.N)
37 
38 # 调用普通方法
39 o1.a1()
40 # 调用静态方法
41 F1.a2(1,2)

 

继承

 1 class F1:
 2     def __init__(self):
 3         print('F1')
 4 
 5     def a1(self):
 6         print('F1a1')
 7 
 8     def a2(self):
 9         print('F1a2')
10 
11 class F2(F1):
12     def __init__(self):
13         print('F2')
14 
15     def a1(self):
16         self.a2()
17         print('F2a1')
18 
19     def a2(self):
20         print('F2a2')
21 
22 class F3(F2):
23     def __init__(self):
24         print('F3')
25 
26     def a2(self):
27         print('F3a2')
28 
29 obj = F3()
30 obj.a1()
31 
32 # obj = F3 ==> F3(obj)
33 # obj.al() ==> F3(obj.a1()) ==> F3中没有a1方法，去父类F2中找，父类F2中有al方法,
34 # 此时的self仍是obj ==> 第一步调用self.a2()即obj.a2() ==> 输出'F3a2' ==》第二步输出'F2a1'
35 
36 >>> 
37 F3
38 F3a2
39 F2a1

多态(多种形态)：pass

 

posted @ 2017-06-28 11:14  不知所以  阅读(93)  评论(0)    收藏  举报