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

概述：

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

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

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

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)

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

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

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

#继承
#本例子中给出父类变量的使用及父类方法的调用方法
class SchoolMember(object):
    total=0      #父类静态变量，用来统计学校的总人数（教师、学生）
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def tell(self):
        print("My name is [%s],I'm [%s] years old"%(self.name,self.age))


class Teacher(SchoolMember):
    """ 教师类 """
    def __init__(self,name,age,salary,course):
        SchoolMember.__init__(self,name,age)       #父类属性的继承
        self.salary=salary
        self.course=course
        SchoolMember.total+=1       #父类静态变量的继承
    def tell(self):
        SchoolMember.tell(self)     #父类方法的继承
        print("I'm a teacher,Salary:%s,Course:%s"%(self.salary,self.course))

class Student(SchoolMember):
    """ 学生类 """
    def __init__(self,name,age,classs):
        SchoolMember.__init__(self,name,age)
        self.classs=classs
        SchoolMember.total+=1
    def tell(self):
        SchoolMember.tell(self)
        print("I'm a student,Class:%s"%self.classs)

t1=Teacher("Alex","18","20000","python")
s1=Student("Eric","20","s12")

t1.tell()
s1.tell()
print("学校总人数为：",SchoolMember.total)

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

多继承：

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

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

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

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

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

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

多态：

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

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

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""
    
    print obj.show()
    
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

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) 

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