面向对象编程：类，对象
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
面向对象技术简介
- 类（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不支持多态。
总结
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
最重要的图示：类和对象是在内存中如何保存
