python 学习 ［day7］面向对象

编程模式概念

• 面向过程：根据业务逻辑从上到下写垒代码
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向对象的三大特性

一、封装

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

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