一、术语
对象：根据模板创建的实例，通过实例对象可以调用执行类中的函数
类：类就是一个用关键字Class定义的模板，模板里包含多个函数，函数里实现一系列的功能。
多态：多态从字面上的意思是多种形态、多种形式。换到编程实际中就是：程序接收到1个对象，但完全不了解对象内部的实现方式
封装：封装并不等于多态，封装是指向程序中的其他部分隐藏对象的具体实现细节的原则。
继承：继承简单的说就是和现实生活中子类继承父类的内容一样。在python里是基于子类和父类而言的，子类拥有父类的属性和方法。
二、多态和封装的区别
1.封装可以不关心对象是如何构建的而直接进行使用。
2.多态可以让用户对于不知道是什么类的对象进行方法调用。
三、类和对象
1.类和对象的创建方法：
#这里创建一个类，类名为Person，具有的方法是walk()和say()
class Person: #class 类名
def walk(self): #定义方法walk()：def 函数1(参数1)：语句1
print "i can walk quickly"
def say(self,name): #定义方法say()：def 函数1(参数1)：语句1
print "hello,i am %s" %name
jachy = Person() #用Person类创建1个对象jachy：对象名 = 类名称()
jachy.walk() #jachy对象调用walk()方法
jachy.say('jachy') #jachy对象调用say()方法
注意：
1.类中的函数我们称为方法
2.类中的函数的第一个参数必须是self
面向对象和函数式编程的区别：
1.面向对象：创建对象--->通过对象执行方法
2.函数编程：执行函数
四、面向对象的三大特性：封装+继承+多态
1.封装，简单的说，将属性封装在某一个地方，以方便后续调用封装的属性
-------->先封装
class Person：
def __init__(self,name,age): #这个__init__（）称为构造方法，当类创建对象是自动就执行了此方法
self.name = name #将传进来的name封装到self中
self.age = age #再将传进来的age封装到self中
#这里self是形参，
#当执行下面的obj1 = Person('jachy',21)时，self就相当于obj1
#当执行下面的obj1 = Person('lilin',22)时，self就相当于obj2
#根据类Person创建对象obj1，
#创建的同时自动执行了类Person中的__init__方法
obj1 = Person('jachy',21) #将jachy和21封装到obj1对象汇总
obj2 = Person('lilin',22) #将lilin和22封装到obj2对象汇总
#两个属性就被封装到obj1和obj2中，
对象obj1有name='jachy'和age=21，在内存中就将name和age封装到对象里面了
对象obj2有name='lilin'和age=22，在内存中就将name和age封装到对象里面了
----->再调用:
调用分2种：1、通过对象直接调用 2.通过self间接调用
1.通过self间接调用
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def message(self):
print self.name
print self.age
#python内部会将obj1传给Person()中的self参数，即self = obj1
obj1 = Person('jachy',21)
obj1.message()
2.通过对象直接调用
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
obj1=Person('jachy',21)
print obj1.name #直接调用obj1对象的属性name
print obj1.age #直接调用obj1对象的属性age
2.继承，简单的说继承就是现实生活中的父与子继承的关系，即定义了1个子类，子类可以使用父类定义的方法和属性，这个过程就是继承
--->继承模板1:单继承
class 父类名:
def func1(self):
pass
class 子类名(父类名):
pass
#创建子类对象
sub = 子类名()
#执行从父类继承的方法
sub.func1()
class Animal:
def eat(self):
print '%s eat ' %(self.name)
def sleep(self):
print '%s sleep ' %(self.name)
#定义子类Cat
class Cat(Animal):
def __init__(self,name):
self.name = name
self.sth= 'cat'
def cry(self):
print "miao--miao"
#定义1个子类Dog
class Dog(Animal):
def __init__(self,name):
self.name = name
self.sth = "dog"
def cry(self):
print "wang--wang"
#真正执行
c1 = Cat('black-cat')
c1.eat()
c2 = Dog('white-dog')
c2.eat()
--->继承模板2:多继承（分为经典继承和新式继承）
class D: #这种类型就是经典类
def bar(self):
print 'D.bar'
class C(D):
def bar(self):
print 'C.bar'
class B(D):
def bar(self):
print 'B.bar'
class A(B,C): #最终调用bar的查找顺序：A --B --D ---C
def bar(self):
print 'A.bar'
a = A()
#首先会执行bar()方法，然后就会在与它相关的几个类去查找，一旦找到就立即停止查找，若最终都没有找到，就报错
#然后第一去A类中查找，A类中没有bar方法，则去B类；若B类没有bar方法就去D类；若D类中没有最后去C类
class D(object): #这种类型就是新式类
def bar(self):
print 'D.bar'
class C(D):
def bar(self):
print 'C.bar'
class B(D):
def bar(self):
print 'B.bar'
class A(B,C):
def bar(self):
print 'A.bar'
c = A()
#首先执行bar方法，然后就去类中寻找
#因为此类是新式类，查找顺序：A---B----C ---D
a.bar()
经典类查找顺序：A---B ---D ---C(深度优先查找策略)
新式类查找顺序：A---B----C----D（广度优先查找策略）
