Python面向对象程序设计类的多态用法详解
本文实例讲述了Python面向对象程序设计类的多态用法。分享给大家供大家参考，具体如下：
多态
1、多态使用
一种事物的多种体现形式,举例:动物有很多种
注意:继承是多态的前提
函数重写就是多态的体现形式
演示:重写Animal类
第一步:先定义猫类和老鼠类,继承自object,在其中书写构造方法和eat方法
第二步:抽取Animal父类,定义属性和eat方法,猫类与老鼠类继承即可
第三步:定义人类,在其中分别定义喂猫和喂老鼠的方法
第四步:使用多态,将多个喂的方法提取一个。
#测试类
fromcatimportCat
frommouseimportMouse
frompersonimportPerson
'''
多态:一种事物的多种状态
需求:人可以喂任何一种动物
'''
#创建猫和老鼠的对象
tom=Cat("tom")
jerry=Mouse("jerry")
#调用各自的方法
tom.eat()
jerry.eat()
#定义了一个有name属性和eat方法的Animal类,让所有的动物类都继承自Animal.
#定义一个人类,可以喂猫和老鼠吃东西
per=Person()
#per.feedCat(tom)
#per.feedMouse(jerry)
#思考:人要喂100种动物,难道要写100个feed方法吗?
#前提:tom和jerry都继承自动物
per.feedAnimal(tom)
per.feedAnimal(jerry)
输出：
tom吃
jerry吃
给你食物
tom吃
给你食物
jerry吃
#animal.py文件中的动物类 classAnimal(object): def__init__(self,name): self.name=name defeat(self): print(self.name+"吃")
#cat.py文件中的猫类 classCat(Animal): def__init__(self,name): #self.name=name super(Cat,self).__init__(name)
#mouse.py中的老鼠类 classMouse(Animal): def__init__(self,name): #self.name=name super(Mouse,self).__init__(name)
#person.py中的人类
classPerson(object):
deffeedAnimal(self,ani):
print("给你食物")
ani.eat()
2、对象属性与类属性
对象属性和类属性的区别:
a.定义的位置不同,类属性是直接在类中的属性,对象属性是在定义在构造方法中的属性；
b.对象属性使用对象访问,类属性使用类名访问；
c.在内存中出现的时机不同[类属性随着类的加载而出现,对象属性随着对象的创建而出现]；
d.优先级不同,对象属性的优先级高于类属性。
classPerson(object):
#1.定义位置
#类属性:直接定义在类中的属性
name="person"
def__init__(self,name):
#对象属性:定义在构造方法中的属性
self.name=name
#2.访问方式
print(Person.name)
per=Person("tom")
#对象属性的优先级高于类属性
print(per.name)
#动态的给对象添加对象属性
per.age=18
#只针对当前对象生效,对于类创建的其他对象没有作用
print(Person.name)
per2=Person("lilei")
#print(per2.age)#没有age属性
#删除对象中的name属性,再调用会使用到同名的类属性
delper.name
print(per.name)
#注意事项:不要将对象属性与类属性重名,因为对象属性会屏蔽掉类属性,但是当删除对象属性之后,再使用就能使用到类属性了.
输出：
person
tom
person
person
3、动态添加属性和方法
正常情况下，我们定义了一个class，创建一个class的实例后，我们可以给该实例绑定任何的的属性和方法，这就是动态语言的灵活性。
python语言的特点:灵活。
这里说的动态添加属性和方法主要指的是关于slots函数的使用
fromtypesimportMethodType
#定义一个空类
'''
classPerson():
pass
'''
classPerson(object):
__slots__=("name","age","speak","hobby")
pass
#动态添加属性[体现了动态语言的特点:灵活性]
per=Person()
per.name="tom"
print(per.name)
#动态添加方法
defsay(self):
print("mynameis"+self.name)
per.speak=say
per.speak(per)
#这样实现不好,所以引入MethodType
defhobby(self):
print("myhobbyisrunning")
per.hobby=MethodType(hobby,per)
per.hobby()
输出：
tom
mynameistom
myhobbyisrunning
但是，给一个实例绑定的方法对另外一个实例是不起作用的。
为了给所有的实例都绑定方法，可以通过给class绑定方法
#动态添加方法
defsay(self,name):
self.name=name
print("mynameis"+self.name)
Person.speak=say
per2=Person()
per2.speak('hh')
输出：
mynameishh
给class绑定方法后，所有的实例均可调用。
4、slots
通常情况下，上面的say方法可以直接定义在class中，但动态绑定允许我们在程序在运行的过程中动态的给class添加功能，这在静态语言中很难实现。
如果我们想限制实例的属性怎么办?
比如，只允许给Person实例添加name，age属性，为了达到限制的目的，Python中允许在定义class的时候，定义一个特殊的变量【slots】变量，来限制该class添加的属性
classPerson(object):
__slots__=("name","age")
#[不想无限制的任意添加属性]
#比如,只允许给对象添加name,age属性
#解决:定义类的时候,定义一个特殊的属性(__slots__),可以限制动态添加的属性范围
per=Person()
per.height=170
print(per.height)
这样做会报错
AttributeError:'Person'objecthasnoattribute'height'
使用slots的时候需要注意，slots定义的属性仅仅对当前类的实例起作用，对继承的子类是不起作用的。
除非在子类中也定义slots，这样子类实例允许定义的属性就是自身的slots加上父类的slots。
总结：
__slots__:
语法：
__slots__=(属性名1,属性名2,...)
作用：
限制类的属性名
注意：当子类没有添加slots时，子类继承父类的时候，它的属性名不受父类的影响
若子类中也添加slots，子类的限制应该是父类的slots与子类slots的并集
5、@property
绑定属性时，如果我们直接把属性暴露出去，虽然写起来简单，但是没有办法检查参数，导致可以随意的更改。
比如：
p=Person() p.age=-1
这显然不合常理，为了限制age的范围，我们可以通过setAge()的方法来设置age，再通过getAge()的方法获取age，这样在setAge()中就可以检查输入的参数的合理性了。
classPerson(object):
def__init__(self,name,age):
#属性直接对外暴露
#self.age=age
#限制访问
self.__age=age
self.__name=name
#self.__name=name
defgetAge(self):
returnself.__age
defsetAge(self,age):
ifage<0:
age=0
self.__age=age
#通过@property和@age.setter改变原来的get/set方法
#方法名为受限制的变量去掉双下划线
#相当于get方法
@property
defage(self):
returnself.__age
#相当于set的方法
@age.setter#去掉下划线.setter
defage(self,age):
ifage<0:
age=0
self.__age=age
@property
defname(self):
returnself.__name
@name.setter
defname(self,name):
self.__name=name
per=Person("lili",18)
#属性直接对外暴露
#不安全,没有数据的过滤
#per.age=-10
#print(per.age)
#使用限制访问,需要自己写set和get的方法才能访问
#劣势:麻烦,代码不直观
#思考问题:如果我就想使用对象"."的方式访问对象的私有属性,怎么办?
#per.setAge(15)
#print(per.getAge())
#property:可以让你对受限制访问的属性使用"."语法
per.age=80#相当于调用setAge
print(per.age)#相当于调用getAge
print(per.name)
输出：
80
lili
property
总结语法：
针对私有化的属性添加的。
@property def属性名(self): returnself.__属性名
@属性名.setter def属性名(self,值): #业务逻辑处理 self.属性名=值
总结:
a.装饰器(decorator)可以给函数动态加上功能,对于类的方法,装饰器一样起作用,python内置的@property装饰器就是负责把一个方法变成属性调用的。
b.@property的实现比较复杂,我们先考虑如何使用,把一个getter方法变成属性,只需要加上@property就可以了,此时@property本身又创建了另一个装饰器@属性setter,负责把一个setter方法变成属性赋值.
c.@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序运行时就减少了出错的可能性。
6、运算符重载
类可以重载加减运算，打印，函数调用，索引等内置运算，运算符重载使我们的对象的行为与内置函数一样，在python调用时操作符会自动的作用于类的对象，python会自动的搜索并调用对象中指定的方法完成操作。
1、常见运算符重载方法
#举例
#数字和字符串都能相加
#print(1+2)
#print("1"+"2")
#不同的类型用加法会有不同的解释
classPerson(object):
def__init__(self,num):
self.num=num
#运算符重载
def__add__(self,other):
returnPerson(self.num+other.num)
#方法重写
def__str__(self):
return"num="+str(self.num)
#如果两个对象相加会怎样?
#对象相加,编译器解释不了,所以就要用到运算符重载
per1=Person(1)
per2=Person(2)
print(per1+per2)
#结果为地址:per1+per2===per1.__add__(per2),如果想得到num的和则重写str方法
#上述打印就等价于:print(per1.__add__(per2)),只不过add方法会自动调用
print(per1)
print(per2)
输出：
num=3
num=1
num=2
更多关于Python相关内容感兴趣的读者可查看本站专题：《Python面向对象程序设计入门与进阶教程》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python编码操作技巧总结》及《Python入门与进阶经典教程》
希望本文所述对大家Python程序设计有所帮助。