面向对象1

参考：http://www.cnblogs.com/wupeiqi/

概述

python 的编程方式分为三种

• 面向过程：根据业务的逻辑，从上到下一行一行的编写代码
• 函数式：将某些功能封装在函数里，需要调用时只需要调用函数
• 面向对象：对函数进行再次封装与分类，更方便的进行开发

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

• 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
• 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

创建类和对象

• class 是类的关键字，表示类，像 def 是函数的关键字一样表示函数
• 创建对象 也叫类的实例化，即类后面直接跟()
• 方法 即类中定义的函数

# 创建类
class Foo(object):
    """
    类的帮助信息
    """

    # 创建类中的函数
    # self 为特殊的参数，必填
    def func(self):
        pass

# 根据类 Foo 创建对象 obj
obj = Foo()

# 调用 func 方法
obj.func()

通过函数式编程和面向对象编程来执行一个方法(函数)的时候，函数式编程要比面向对象简便

面向对象：

• 创建对象
• 通过对象执行方法

函数式：

• 执行函数

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

面向对象的三大特性

面向对象的三大特性分别指的是：封装，继承和多态

一、封装

封装就是将方法，字段，属性等信息集体封装在某处，方便以后调用

1、将方法、字段、属性等信息封装

# 创建类
class Foo(object):
    # 构造方法，根据类创建对象时自动执行
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 通过类 Foo 创建对象 obj1
obj1 = Foo('WenChong', 10)

# 通过类 Foo 创建对象 obj2
obj2 = Foo('Alan', 10)

self 是一个形式参数

当执行 obj1 = Foo('WenChong', 10) 时，self = obj1

当执行 obj2 = Foo('Alan', 10) 时，self = obj2

内容被封装到了 obj1 和 obj2 中，obj1 和 obj2 都有 name 和 age 两个属性

2、调用封装的内容

调用被封装的内容有两种方法

• 通过 对象 直接调用
• 通过 self 间接调用

# 创建类
class Foo(object):
    # 构造方法，根据类创建对象时自动执行
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 通过类 Foo 创建对象 obj1
obj1 = Foo('WenChong', 10)
print(obj1.name)    # 直接调用 obj1 的 name 属性
print(obj1.age)     # 直接调用 obj1 的 age 属性

# 通过类 Foo 创建对象 obj2
obj2 = Foo('Alan', 10)
print(obj2.name)    # 直接调用 obj2 的 name 属性
print(obj2.age)     # 直接调用 obj2 的 age 属性

# 创建类
class Foo(object):
    # 构造方法，根据类创建对象时自动执行
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name)
        print(self.age)

# 通过类 Foo 创建对象 obj1
obj1 = Foo('WenChong', 10)
# 通过调用 show 方法，show 方法的第一个参数 self = obj1，即 self.name = 'WenChong', self.age = 10
obj1.show()

# 通过类 Foo 创建对象 obj2
obj2 = Foo('Alan', 10)
# 通过调用 show 方法，show 方法的第一个参数 self = obj2，即 self.name = 'Alan', self.age = 10
obj2.show()

二、继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

对于面向对象来说，就是将多个子类的方法提取出来放到父类中，子类仅需继承父类的方法，而不需要一一实现

继承的语法

class 子类(父类[,父类1,父类2...]):
    pass

单继承

当子类继承了一个父类时，如果子类中没有被调用的方法，会在父类中查找，如果父类中也没有，会继续在父类的父类中查找。

# 创建 animal 类，包含了 cat 和 dog 的共有方法
class Animal(object):

    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)


# 创建 Cat 类，只包含 Cat 独有的方法
class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')

# 创建 Dog 类，只包含 Dog 独有的方法
class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    def cry(self):
        print('汪汪叫')


# 根据类创建对象，并执行
cat = Cat('小白家的小黑猫')
cat.cry()
cat.eat()
cat.drink()

多继承

当一个子类继承多个父类时，称之为多继承

class A(object):
    def foo2(self):
        print('A')

class B(A):
    def foo1(self):
        print('B')


class C(B):
    def foo1(self):
        print('C')


class D(A):
    def foo2(self):
        print('D')


class E(D):
    def foo1(self):
        print('E')


class F(C, E):
    def foo1(self):
        print('F')

obj = F()
obj.foo2()

上例中最后的输出结果为 D

当一个子类继承多个父类的时候，寻找方法的方式遵循 C3 算法，即如图的顺序在父类中查找方法

python 2.x 的不同

python 2.7 中分为广度优先算法和深度优先算法

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

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

三、多态

 多种形态

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) 

 补充

类和对象在内存中的保存

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

当通过 obj1 执行 【方法一】 时，过程如下：

1. 根据当前对象中的 类对象指针 找到类中的方法
2. 将对象 obj1 当作参数传给 方法的第一个参数 self