python语言不支持面向对象_python面向对象编程语言

面向对象的编程语言简单来说就是基于对类和对象的使用，所有的代码都是通过类和对象实现的编程语言。

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

创建一个类：

#使用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()    #访问类方法

输出：

普通方法

静态方法

类方法

普通方法：先创建一个对象，在用对象去调用这个方法

静态方法：直接用类调用，可以有任意参数(静态方法可以让类直接调用，省去了普通方法创建对象的步骤)

类方法：直接用类调用，只能一个cls参数

上面我们可以看到执行类方法时，输出了他传入的参数等于，是一个类，意思就是执行时，它会把当前的类当成参数传进去。

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