python之路——面向对象（基础篇）

面向对象编程：类，对象

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

面向对象技术简介

• 类（class）:用来描述有相同属性和方法的对象的集合，它定义了集合中每个对象所共有的属性和方法。
• 对象（object）：类的实例

创建类和对象

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

    def talk(self,msg):
        print("%s-talk:%s"%(self.name,self.msg))
obj = Person("alex","23")    

• class 是关键字表示类，后边紧跟着类名"Person"
• 创建对象obj = Person()->类名加括号（有参数，要传递构造方法的参数进去）
• self是个什么东西呢？

self:python自动传递的参数，代表你实例的对象。通过self可以调用该对象的相应属性和方法。

• 构造方法："__init__(self,name,age)";只要创建对象，就会自动去执行该方法然后我就可以用对象直接访问：obj.name &obj.age

p_obj1 = Person("alex","23")
p_obj2 = Person("lcy","24")
print(p_obj1.name,p_obj1.age)# alex 23
print(p_obj2.name,p_obj2.age)# lcy 24

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

封装

• 将内容封装到类中
• 在从类中调用封装的方法或属性

Ex：

class Person：
    
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
    
    def show(self,obj):
        print(self.name,obj.name)


obj_1 = Person("sb","male",23)
obj_2 = Person("json","female",24)

obj_1.show(obj_2) 
'''
打印：sb;json
'''

注:在类中可以封装任意类型的数据

继承

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

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。

• 单继承
• 多继承

1. 单继承

class A:
    
    def show(self):
        print("A:show")

    def aa(self):
        print("A:aa")

class B(A):
    
    def show(self):
        print("B:show")

    def bb(self):
        print("B:bb")

class C(B):
    
    def show(self):
        print("C:show")

    def cc(self):
        print("C:cc")

obj_c = C()
obj_c.show()  #优先调用自己的方法，如果自己没有，在去父类中找
obj_c.bb()

再看一个例子：

class A:

    def __init__(self,name):
        self.name = name

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

class B(A):

    def __init__(self,name):
        self.name = name

obj_a = A("alex")
obj_b = B("lcy")
obj_b.show() # show 会打印谁 是 lcy 还是 alex

想一想我们之前说过的self，这里是子类B对象obj_b调用父类A的show方法，那么self传递的肯定是obj_b 这个对象。所以打印的是obj_b.name = lcy；

　　2. 多继承

举一个简单多继承(python3)

class C0:
    def  f2(self0):
        print("C0-f2")

class C1(C0):
    def f1(self):
        print("C1-f1")

class C2:

    def f2(self):
        print("C2-f2")
class C3(C1,C2):
    def f3(self):
        print("C3-f2")

obj = C3() 
obj.f2()

我们看obj 调用f2应该是谁的方法呢？

按着继承顺序，寻找路径应该是C3->C1->C0->C2 (这个其中C2并不继承任何类)见图1

注意：如果C2继承C0，那么寻找路径就编程了C3->C1->C2->C0 见图2

图1

图二

在举一个看程序源码时候对象调用方法的一个执行顺序

class C5:
    def forever(self):
        self.run()

    def run(self):
        print("C5-run")
class C4(C5):
    def __init__(self):
        print("C4-init")

    def process(self):
        pass

    def run(self):
        print("C4-run")
        self.process()

class C3(C4):
    def __init__(self):
        print("C3-init")

class C2:
    def process(self):
        print("C2-process")

class C1(C2,C3):
    pass

obj = C1()
obj.forever()
'''
C3-init
C4-run
C2-process
'''

顺序图：首先C1（）调用构造，寻找init方法路径 C1->C2->C3(找到了)->C4->C5

调用forever方法，寻找路径C1->C2->C3->C4->C5(找到了)

forever又执行了 self.run方法 继续寻找:C1->C2->C3->C4(找到了)->C5

run方法又执行了self.process()方法 继续寻找：C1->C2（找到了返回结果）->C3->C4->C5

     3. 多态

python不支持多态。

总结 

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

最重要的图示：类和对象是在内存中如何保存