面向对象相关知识点及常见的操作

概述：

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

面向对象的三大特征：封装、继承、多态

封装：即将实现某些功能的代码封装到类中，在使用时通过实例化调用即可

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=1500):
        self.name=name
        self.role=role
        self.weapon=weapon
        self.life_value=life_value
        self.money=money

    def buy_gun(self,weapon):
        self.weapon=weapon
        print("%s buy a new [%s]"%(self.name,weapon))


#r1为类的对象，即类的实例化过程，self实例本身，Role类本身
r1=Role("Alex","Police","AK47")
r1.buy_gun("B11")
print("r1的weapon的是：",r1.weapon)

View Code

如上述例子，首先建立角色类，在类中定义相关属性和常用操作，然后通过类来创建实例对象，并将类的属性和方法随对象的创建而复制

继承：面向对象中的继承和现实中的继承类似，即子类可以继承父类的所有内容

继承的宗旨是让具有相同属性和方法的一类事物抽象出来，进行属性和方法定义，然后针对特殊的属性和方法，单独定义，为了让其具有与其他类相关的属性，则让其继承其父类的属性和方法：即：将多个类共同的属性和方法提取到父类中，子类只需定义特殊的属性和方法

 1 #继承
 2 #本例子中给出父类变量的使用及父类方法的调用方法
 3 class SchoolMember(object):
 4     total=0      #父类静态变量，用来统计学校的总人数（教师、学生）
 5     def __init__(self,name,age):
 6         self.name=name
 7         self.age=age
 8     def tell(self):
 9         print("My name is [%s],I'm [%s] years old"%(self.name,self.age))
10 
11 
12 class Teacher(SchoolMember):
13     """ 教师类 """
14     def __init__(self,name,age,salary,course):
15         SchoolMember.__init__(self,name,age)       #父类属性的继承
16         self.salary=salary
17         self.course=course
18         SchoolMember.total+=1       #父类静态变量的继承
19     def tell(self):
20         SchoolMember.tell(self)     #父类方法的继承
21         print("I'm a teacher,Salary:%s,Course:%s"%(self.salary,self.course))
22 
23 class Student(SchoolMember):
24     """ 学生类 """
25     def __init__(self,name,age,classs):
26         SchoolMember.__init__(self,name,age)
27         self.classs=classs
28         SchoolMember.total+=1
29     def tell(self):
30         SchoolMember.tell(self)
31         print("I'm a student,Class:%s"%self.classs)
32 
33 t1=Teacher("Alex","18","20000","python")
34 s1=Student("Eric","20","s12")
35 
36 t1.tell()
37 s1.tell()
38 print("学校总人数为：",SchoolMember.total)

上述代码中，给出了python中典型的继承，包含父类属性、方法及静态变量的继承；

多继承：

问题：是否能实现多继承？

答：python可以实现多继承，即一个类继承多个类

问题：如果继承的多个类中每个类都有相同的函数，则调用哪一个函数呢？

答：python的类分为经典类（class FOO）和新式类（class FOO()）

经典类中：深度优先查找，即先查找第一个继承的类，然后查询该类的父类是否有该方法，即：儿子有问题先找爸爸，爸爸没找到则去找爷爷

新式类中：广度优先查找，即先查找第一个继承的类，没有找到则查询第二个继承的类，若仍旧没找到，则查找继承类的父类，即儿子有问题，找完爸爸找妈妈，实在不行再找爷爷

多态：

Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。

先看Java和C#中的多态的伪代码

 1 class F1:
 2     pass
 3 
 4 
 5 class S1(F1):
 6 
 7     def show(self):
 8         print 'S1.show'
 9 
10 
11 class S2(F1):
12 
13     def show(self):
14         print 'S2.show'
15 
16 
17 # 由于在Java或C#中定义函数参数时，必须指定参数的类型
18 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
19 # 而实际传入的参数是：S1对象和S2对象
20 
21 def Func(F1 obj):
22     """Func函数需要接收一个F1类型或者F1子类的类型"""
23     
24     print obj.show()
25     
26 s1_obj = S1()
27 Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
28 
29 s2_obj = S2()
30 Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

python的“鸭子”类型

 1 class F1:
 2     pass
 3 
 4 
 5 class S1(F1):
 6 
 7     def show(self):
 8         print 'S1.show'
 9 
10 
11 class S2(F1):
12 
13     def show(self):
14         print 'S2.show'
15 
16 def Func(obj):
17     print obj.show()
18 
19 s1_obj = S1()
20 Func(s1_obj) 
21 
22 s2_obj = S2()
23 Func(s2_obj)

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