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","")

 p_obj2 = Person("lcy","")

 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 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。

单继承
多继承

单继承

 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不支持多态。

总结

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

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