python——面向对象编程

面向对象编程

面向对象编程是一种编程方式，此编程方式须要使用 “类” 和 “对象” 来实现，因此，面向对象编程其实就是对 “类” 和 “对象” 的使用。

• 类(class)就是一个模板，模板里能够包含多个函数，函数里实现一些功能
• 对象则是根据模板建立的实例，经过实例对象能够执行类中的函数

 1 # 建立类
 2 class Foo(object):    #新式类（经典类 class Foo:）
 3 
 4     def Bar(self):
 5 
 6         print 'Bar'
 7 
 8     def Hello(self, name):
 9 
10         print 'i am %s' %name
11 
12 # 根据类Foo建立对象obj
13 
14 obj = Foo()
15 
16 obj.Bar()            #执行Bar方法
17 
18 obj.Hello('x54256') #执行Hello方法

面向对象3大特色：

1、封装 

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

因此，在使用面向对象的封装特性时，须要：

• 将内容封装到某处
• 从某处调用被封装的内容（在类中的其余函数中须要经过self来间接的调用被封装的内容）

 1 class Foo(object):
 2     def __init__(self,name,age):    #构造函数，根据类建立对象时（实例化）自动执行
 3         self.name=name
 4         self.age=age
 5     
 6     def run():
 7         print("%s今年%s岁了。"%(self.name,self.age)
 8         
 9 
10 #实例化（就是将内容封装到某处）
11 #实际上alex和22被封装到了obj1中，x54256和21被封装到了obj2中
12 
13 obj1=Foo('alex',22)
14 
15 obj2=Foo('x54256',21)
16 
17 
18 #若要调用必须从obj1，obj2中调用封装的内容
19 
20 print(obj1.name)
21 print(obj2.name)
22 
23 #要从被封装的地方调用类中的函数
24 
25 obj1.run()    
26 obj2.run()

封装代码

2、继承

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

例如：

　　猫能够：喵喵叫、吃、喝、拉、撒

　　狗能够：汪汪叫、吃、喝、拉、撒

若是咱们要分别为猫和狗建立一个类，那么就须要为 猫 和 狗 实现他们全部的功能，以下所示：

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

伪代码

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

　　动物：吃、喝、拉、撒

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

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

 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 '喵喵叫'
26 
27 伪代码

伪代码

 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()

3、多态

多态性（polymorphisn）是容许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值以后，父对象就能够根据当前赋值给它的子对象的特性以不一样的方式运做。简单的说，就是一句话：容许将子类类型的指针赋值给父类类型的指针。

那么，多态的做用是什么呢？咱们知道，封装能够隐藏实现细节，使得代码模块化；继承能够扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另外一个目的—— 接口重用！多态的做用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 1 class Animal(object):
 2 
 3     def __init__(self, name):  # Constructor of the class
 4 
 5         self.name = name
 6 
 7     def talk(self):              # Abstract method, defined by convention only
 8 
 9         raise NotImplementedError("Subclass must implement abstract method")
10 
11 class Cat(Animal):
12 
13     def talk(self):
14 
15         print('%s: 喵喵喵!' %self.name)
16 
17 
18 class Dog(Animal):
19 
20     def talk(self):
21 
22         print('%s: 汪！汪！汪！' %self.name)
23 
24 
25 def func(obj): #一个接口，多种形态
26 
27     obj.talk()
28 
29 
30 c1 = Cat('小晴')
31 
32 d1 = Dog('李磊')
33 
34 
35 func(c1)
36 
37 func(d1)

领域模型 

领域模型就是对需求所涉及的领域的一个建模,更通俗的讲法是业务模型。 参考百度百科领域模型定义以下: (http://baike.baidu.cn/view/757895.htm )

从这个定义咱们能够看出,领域模型有两个主要的做用:

1. 发掘重要的业务领域概念
2. 创建业务领域概念之间的关系 

领域域建模的方法就是“从用例中找名词”。 固然,找到名词后,为了可以更加符合面向对象的要求和特色,咱们还须要对这些名词进一步完善,这就 是接下来的步骤:加属性,连关系! 

1.找名词

who : 学员、讲师、管理员

用例：

1. 管理员 建立了 北京 和 上海 两个校区

2. 管理员 建立了 Linux \ Python \ Go 3个课程 

3. 管理员 建立了 北京校区的Python 16期， Go开发第一期，和上海校区的Linux 36期 班级

4. 管理员 建立了 北京校区的 学员 小晴 ，并将其 分配 在了 班级  python 16期 

5. 管理员 建立了 讲师 Alex , 并将其分配 给了 班级 python 16期 和全栈脱产5期

6. 讲师 Alex 建立 了一条 python 16期的 上课纪录 Day6 

7. 讲师 Alex 为Day6这节课 全部的学员 批了做业 ，小晴得了A, 李磊得了C-, 严帅得了B

8. 学员小晴 在 python 16 的 day6里 提交了做业 

9. 学员李磊 查看了本身所报的全部课程 

10 学员 李磊  在 查看了 本身在 py16期 的 成绩列表 ，而后自杀了

11. 学员小晴  跟 讲师 Alex 表白了

名词列表：

管理员、校区、课程、班级、上课纪录、做业、成绩、讲师、学员

2.加属性

3.连关系 

有了类,也有了属性,接下来天然就是找出它们的关系了。

 

总结

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

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

问答专区

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

答：从简单来讲，若是程序中的全部功能都是用 类 和 对象 来实现，那么就是面向对象编程了。

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

答：须知：对于 C# 和 Java 程序员来讲不存在这个问题，由于该两门语言只支持面向对象编程（不支持函数式编程）。而对于 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.须要建立多个事物，每一个事物属性个数相同，可是值的需求
如：张3、李4、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

 

 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')

实例代码

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

答：类以及类中的方法在内存中只有一份，而根据类建立的每个对象都在内存中须要存一份，大体以下图：