面向对象的编程语言简单来说就是基于对类和对象的使用，所有的代码都是通过类和对象实现的编程语言。
面向对象的三大特性：继承、封装、多态。
创建一个类：
#使用class创建一个School类,类中有个student方法
class School:
def student(self):
passa1=School()
一、封装
1.封装：将某些内容先封装到一个地方，等到需要的时候再去调用。
class School:
def __init__(self,name,age): #构造方法，创建对象时执行
self.name=name
self.age=age
#创建对象a1,a2
a1=School("zhangsan",18)
a2=School("lisi",18)
上面的内容就是实现封装的功能，把各自的姓名和年龄封装到了self的name和age中，就等于被封装到了对象a1和a2中。
类中定义的函数叫方法，__init__的函数叫构造方法，在创建a1和a2时创建。
2.调用：调用有两种方式调用，通过self间接调用和通过对象直接调用。
#通过对象直接调用
class School:
def __init__(self,name,age):
self.name=name
self.age=age
def student(self):
print("name:%s,age:%s"%(self.name,self.age))
#创建对象a1,a2
a1=School("zhangsan",18)
a2=School("lisi",18)
print a1.name,a1.age
print a2.name,a2.age
#执行结果:
zhangsan 18
lisi 18
#通过self间接调用
class School:
def __init__(self,name,age):
self.name=name
self.age=age
def student(self):
print("name:%s,age:%s"%(self.name,self.age))
#创建对象a1,a2
a1=School("zhangsan",18)
a2=School("lisi",18)
#执行类中的方法时，通过self间接调用被封装的内容
a1.student()
a2.student()
#执行结果:
name:zhangsan,age:18
name:lisi,age:18
二、继承
1、继承：派生类（子类）可以继承基类（父类）的方法，我们可以将多个类共有的方法提取到父类中，这样子类只需继承父类而不必实现每个方法。在类名后面括号中写上另一个类，表示继承了那个类
#ex45.py
#使用class创建一个School类
class School:
def __init__(self,name,age):
self.name=name
self.age=age
def student(self):
print("name:%s,age:%s"%(self.name,self.age))
def classroom(self):
print("%s去教室"%self.name)
class SchoolA(School): #SchoolA继承School
def __init__(self,name):
self.name=name
class SchoolB(SchoolA): #SchoolB继承SchoolA
def __init__(self,name):
self.name=name
#创建对象a1
a1=SchoolA("zhangsan")
a1.classroom()
#创建对象a2
a2=SchoolB("lisi")
a2.classroom()
输出：
zhangsan去教室
lisi去教室
2.多继承
在python中类可以继承多个类，在继承多个类时，他对类中的函数查找有两种方式。
深度优先：类是经典类时，多继承情况下，会按照深度优先方式查找。
广度优先：类是新式类时，多继承情况下，会按照广度优先方式查找
python3.X下都是广度优先
class A():
def name(self):
print("AAAAAA")
class B(A):
pass
class C(A):
def name(self):
print("CCCCCC")
class D(B,C):
pass
a1=D()
a1.name() #输出：CCCCCC
三、多态
python不支持多态，也用不到多态。
四、类中的成员
类中的成员：字段、方法、属性
1、字段
字段：普通字段、静态字段
class School:
headmaster="王五"
def __init__(self,name,age):
self.name=name
self.age=age
def student(self):
print("name:%s,age:%s"%(self.name,self.age))
#创建对象a1
a1=School("zhangsan",18)
print(a1.name) #访问普通字段
print(School.headmaster) #访问静态字段
#执行结果:
# zhangsan
# 王五
在上面代码中，__init__函数中的就是普通字段，headmaster就是静态字段
普通字段：属于对象，由对象来访问，在内存中每个对象都要保存一份
静态字段：属于类，由类直接访问，在内存中只保存一份
2、方法
方法：普通方法、静态方法、类方法
class School:
headmaster="王五"
def __init__(self,name,age):
self.name=name
self.age=age
def student(self): #普通方法 至少一个self
print("普通方法")
@staticmethod #静态方法 任意参数
def classroom():
print("静态方法")
@classmethod
def dormitory(cls): #类方法 只能一个cls
print("类方法",cls)
#创建对象a1
a1=School("zhangsan",18)
a1.student()
School.classroom() #访问静态方法
School.dormitory() #访问类方法
输出：
普通方法
静态方法
类方法 <class '__main__.School'>
普通方法：先创建一个对象，在用对象去调用这个方法
静态方法：直接用类调用，可以有任意参数(静态方法可以让类直接调用，省去了普通方法创建对象的步骤)
类方法：直接用类调用，只能一个cls参数
上面我们可以看到执行类方法时，输出了他传入的参数等于<class '__main__.School'>，是一个类，意思就是执行时，它会把当前的类当成参数传进去。
3、属性
属性定义：装饰器定义、静态字段定义
(1)装饰器定义
class School:
headmaster="王五"
def __init__(self,name,age):
self.name=name
self.age=age
def student(self): #方法
print("方法")
@property
def classroom(self): #属性，加上@property装饰器，仅有一个self参数
print("属性")
#创建对象a1
a1=School("zhangsan",18)
a1.student() #调用方法
a1.classroom #调用属性
输出：
方法
属性
在上面代码中可以看到，在方法上加上@property装饰器就叫属性，属性和方法的区别就是调用时不用加括号
在新式类中，除了@property，还有另外两种装饰器
class School(object):
def __init__(self,name,age):
self.name=name
self.age=age
@property
def classroom(self): #属性，加上@property装饰器，仅有一个self参数
print(self.name,self.age)
@classroom.setter
def classroom(self,age):
self.age=age #把age修改为传入的参数
print("修改",self.name,self.age)
@classroom.deleter
def classroom(self):
del self.age #删除age
print("删除",self.name,self.age)
#创建对象a1
class School(object):
def __init__(self,name,age):
self.name=name
self.age=age
@property
def classroom(self): #属性，加上@property装饰器，仅有一个self参数
print(self.name,self.age)
@classroom.setter
def classroom(self,age):
self.age=age #把age修改为传入的参数
print("修改",self.name,self.age)
@classroom.deleter
def classroom(self,age,name):
del self.age #删除age
print("删除",self.name,self.age)
#创建对象a1
a1=School("张三",18)
a1.classroom #1.执行后会自动调用@property方法
a1.classroom=20 #2.执行后会自动调用@classroom.setter的方法，并将20传给age参数
a1.classroom #3.执行后会自动调用@classroom.deleter的方法
输出：
张三 18
修改 张三 20
张三 20
(2)静态字段定义
class School(object):
def __init__(self,name,age):
self.name=name
self.age=age
def classroom(self):
print(self.name,self.age)
def classroom_update(self,age):
self.age=age #把age修改为传入的参数
print("修改",self.name,self.age)
def classroom_del(self):
del self.age #删除age
print("删除",self.name,self.age)
obj=property(classroom,classroom_update,classroom_del) #静态字段方式定义属性
#创建对象a1
a1=School("张三",18)
a1.obj #1.执行后会自动调用classroom方法
a1.obj=20 #2.执行后会自动调用classroom_update的方法，并将20传给age参数
del a1.obj #3.执行后
输出：
张三 18
修改 张三 20
张三 20
网友评论