面向对象

面向对象

一、什么是面向对象
之前我们学习过面向过程和函数式编程，在讲函数的时候有说过之所以有函数式编程是因为面向过程编程是根据业务逻辑从上到下垒代码，会出现大量代码的重用和臃肿，so，函数式编程将同一功能的代码封装起来，方便日后调用，避免重复编写。而随着业务逻辑的需求，函数式编程一样回出现面向过程同样的问题，于是就有了面向对象编程，以实现对函数进行分类和封装，减少代码量。

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

二、创建类和对象
面向对象编程其实就是对类和对象的使用。类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；对象则是根据模板创建的实例，通过实例对象可以执行类中的函数。

   class Too:#创建类名为Too的类
#创建类中的函数
    def Air(self):#self是特殊参数，必填
        pass
obj=Too()#根据类Too创建对象obj

class Foo:
    def Bar(self):
        print('bar')
    def Hello(self,name):
        print('I am %s'%name)
#根据类Foo创建对象obj
obj=Foo()
obj.Bar()#执行Bar方法
obj.Hello('tina')#执行Hello方法

三、面向对象的三大特性
1、封装

封装，就是讲相同的内容封装到某个地方，方便日后再去调用被封装在某处的内容。so，在使用面向对象的封装时，需要：

将内容封装到某处
从某处调用被封装的内容
#在对象中封装数据的方法一（不推荐）：

class Oldboy:
    def fetch(self,backend):
        print(backend,self)
        return 1

obj1=Oldboy()#创建对象，实例
#在对象中封装数据
obj1.backend='www.xxxxx'
#执行类中的方法
a=obj1.fetch('www')
print(a)

#方法二（推荐）：

class Foo:
    def __init__(self,name,age):#称为构造方法，根据类创建对象时自动执行
        self.name=name
        slef.age=age
#根据类Foo创建对象
#自动执行Foo类的__init__方法
obj1=Foo('tina',18)
obj2=Foo('feifei',22)

self是一个形式参数，当执行obj1=Foo(‘tina’,18)时，self等于obj1，当执行obj2=Foo(‘feifei’,22)，self等于obj2

调用被封装的内容时，又分为两组情况：

(1)、通过对象直接调用：（对象.属性名）

class Foo:
    def __init__(self,name,age):
        self.name=name
        slef.age=age

obj1=Foo('tina',18)
print(obj1.name)#直接调用obj1对象的name属性
print(obj1.age)#直接调用obj1对象的age属性
obj2=Foo('feifei',22)
print(obj2.name)#直接调用obj2对象的name属性
print(obj2.age)#直接调用obj2对象的age属性

(2)、通过self间接调用：（执行类中的方法时，通过self间接调用被封装的内容）

class Foo:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print(self.name)
        print(self.age)
  
obj1 = Foo('tina', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 tina ；self.age 是 18
  
obj2 = Foo('feifei', 22)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是feifei ； self.age 是 22

综上，对于面向对象的封装来说，实质就是使用构造方法将内容封装到对象中，然后通过对象直接或self间接获取被封装的内容。

2、继承

面向对象中的继承跟生活中的继承一个道理，即：子可以继承父的内容。

python中继承跟其他语言不同的地方在于：Java或C++中面向对象的继承只能继承一个，即只能继承父类；而python中面向对象的继承则能继承多个，即可以继承父亲的又可以继承叔叔的，寻找方法的顺序则是从左到右进行溯源。

class Animals:
    def chi(self):
        print(self.name+'吃吃吃')
    def he(self):
        print(self.name+'喝喝喝')
class Dog(Animals):#类名后面有括号就是继承，没括号就是基类
    def __init__(self,name):
        self.name=name
    def jiao(self):
        print(self.name+'汪汪汪')
obj1=Dog('xx')
obj1.jiao()
obj1.chi()
obj1.he()

综上，对于面向对象的继承来说，其实就是将多个共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

*注：子类和父类，又叫派生类和基类。

多继承的优先级关系：当继承多个类发生冲突时，优先级是：先自己，然后先左再右

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类的格式：class Classics:

#经典类多继承的栗子：
class D:                  #经典类
    def bar1(self):
        print("D.bar1")

class C(D):
    def bar1(self):
        print("C.bar1")

class B(D):
    # def bar1(self):
    #     print "B.bar1"
    pass                  #pass 代表什么也不做

class A(B,C):
    # def bar1(self):
    #     print("A.bar1")
    pass                  #pass 代表什么也不做

op = A()                  #实例化对象op
op.bar1()

#######执行结果如下#######
D.bar1

新式类的格式：class New(object):

对于新式类，要在类名后的括号中写上object，object 也是一个类，class New(object)，相当于继承了object 类， 则这个类称为新式类,新式类是我们今后推荐的写法。

#新式类多继承的栗子：class Tina(object):    #新式类
    def f1(self):
        print('Tina')
class A(Tina):
    def f(self):
        print('A')
class B(Tina):
    def f(self):
        print('B')
class C(A):
    def f(self):
        print('C')
class D(B):
    def f(self):
        print('D')
class E(C,D):
    def f(self):
        print('E')
obj=E()
obj.f1()

###########执行结果如下#########
Tina

3、多态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
以下是维基百科中对鸭子类型得论述：

在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试，“鸭子测试”可以这样表述：“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
这里不做过多介绍。
python“鸭子类型”

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) 

Python “鸭子类型”