编程模式概念
- 面向过程：根据业务逻辑从上到下写垒代码
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
面向对象的三大特性
一、封装
第一步：将内容封装到某处
class Teacher: #定义了一个Teacher对象
#__init__ 构造方法，在创建对象时会自动执行类中的构造方法
def __init__(self, favor, name, age): #self类中的所有方法必须包含self参数，self即代表对象本身
self.favor = favor
self.name = name
self.age = age
self.asset = 0 def failure(self): #方法
"""
教学事故
:return:
"""
self.asset -= 1
print("教学事故,asset - 1")
tubie = Teacher('car', 'tubie', 20) #创建对象土鳖，将car,tubie,20分别封装到 favor,name,age中
print(tubie.name)
self 是一个形式参数，当执行 tubie = Teacher('car','tubie', 20) 时，self 等于 tubie
当执行 tubie2 = Teacher('phone','tubie2', 25) 时，self 等于 tubie2
所以，内容其实被封装到了对象 tubie 和 tubie2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
print(tubie.name)
2、通过self间接调用被封装内容
self.asset += 1
面向对象举例
- 小明，10岁，男，上山去砍柴
- 小明，10岁，男，开车去东北
- 小明，10岁，男，最爱大保健
- 老李，90岁，男，上山去砍柴
- 老李，90岁，男，开车去东北
- 老李，90岁，男，最爱大保健
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()
练习1
二、继承
1、单继承
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
例如：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
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
逻辑代码
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
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 '喵喵叫'
逻辑代码
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
2、多继承
1）Python的类可以继承多个类，Java和C#中则只能继承一个类
2）Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
- 当类是经典类时，多继承情况下，会按照深度优先方式查找
- 当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
三、多态
多态即多种形态
class f:
pass class a(f):
def show(self):
print('a.show') class b(f):
def show(self):
print('b.show') # 为了让func函数既可以执行a对象的show方法，又可以执行b对象的show方法，所以，定义了一个a和b类的父类
# 而实际传入的参数是：a对象和b对象
def func(obj):
print(obj.show()) obj1 = a()
func(obj1) # 在func函数中传入a类的对象 obj1，执行 a 的show方法，结果：a.show
obj2 = b()
func(obj2) # 在func函数中传入b类的对象 obj2，执行 b 的show方法，结果：b.show