本章主要内容
- 类与对象
- 定义和使用类
- 类的属性和方法
- 类的继承
- 类的方法重载
class myclass:
"Myclass help."
Myclass = myclass() # 将类实例化
print(myclass.__doc__) # 输出类说明
help(myclass) #输出类帮助信息
Myclass help.
Help on class myclass in module __main__:
class myclass(builtins.object)
| Myclass help.
|
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class println:
def __init__(self,x,y=0): #定义构造方法且初始化实例属性
self.x = x
self.y = y
def func(self):
return self.x*self.y
def info(self): #定义类方法
print('定义类')
def call(self,a,b):
return a + b
c = println(2,2) #实例化类
print(c.func())
c.info()
print(c.call(1,2)) #调用类方法
4
定义类
3
def num(x,y): #定义全局函数
return abs(x),abs(y)
class firstfun:
def __init__(self,x=0,y=0): #定义构造方法
self.x = x
self.y = y
def move(self,x,y):
self.x,self.y = num(x,y) #调用num函数
self.point(self.x,self.y) #方法中调用方法
self.printl(self.x,self.y)
def point(self,x,y):
self.x=x+1
self.y=y+1
print('x=%d,y=%d' % (x,y))
def printl(self,x,y):
print('x=%d,y=%d' % (x,y))
a = firstfun() #实例化对象
a.move(-1,5) #调用对象方法
x=1,y=5
x=2,y=6
#类的属性
'''
实例属性为某个实例化对象所特有
另外对象中的属性互不相关，类属
性为同一个类的实例化对象所共有
一旦改变所有对象中的类属性都会
改变
'''
class myclasspython:
class_name = 'python' #定义类属性为所有对象所共有
def __init__(self,x=0):
self.x = x+1 #实例属性
def infor(self):
print('类属性为：%s,实例属性为：%d'%(myclasspython.class_name,self.x))
def changev(self,x): #改变实例属性的方法
self.x = x
def changecn(self,name): #改变类属性的方法
myclasspython.class_name = name
print('初始化实例变量')
a = myclasspython()
b = myclasspython()
a.infor()
b.infor()
print('修改a的实例变量后')
a.changev(6)
a.infor()
b.infor()
print('修改b的类属性后')
b.changecn('java')
print(a.class_name)
print(b.class_name)
初始化实例变量
类属性为：python,实例属性为：1
类属性为：python,实例属性为：1
修改a的实例变量后
类属性为：python,实例属性为：6
类属性为：python,实例属性为：1
修改b的类属性后
java
java
#类成员方法与静态方法
class DemoMthd:
@staticmethod #静态方法装饰器
def static_mthd(): #静态类定义没有默认参数
print('调用了静态方法')
@classmethod #类方法装饰器
def class_mthd(cls): #类方法需加参数cls
print('调用了类方法')
DemoMthd.static_mthd() #未实例化对象通过类名调用静态与类方法
DemoMthd.class_mthd()
dm = DemoMthd()
dm.static_mthd() #通过实例化对象调用静态与类方法
dm.class_mthd()
调用了静态方法
调用了类方法
调用了静态方法
调用了类方法
#类的继承
'''
子类要想覆盖父类的方法拥有自己的特性
只需要创建与父类方法同名的方法即可
'''
class Ant:
def __init__(self,x=0,y=0,color='black'):
self.x = x
self.y = y
self.color = color
def crawl(self,x,y):
self.x = x
self.y = y
print('爬爬.....')
self.info()
def info(self):
print('当前位置:(%d,%d)'%(self.x,self.y))
def attack(self):
print('用嘴咬')
class flyant(Ant): #flyant继承类Ant
def attack(self): #儿类覆盖父类方法
print('发射尾针...')
def fly(self):
print('飞呀飞呀我的骄傲放纵。。') #模拟蜜蜂飞行动作
ant = Ant() #实例化蚂蚁
print(ant.color)
ant.crawl(3,4)
ant.attack()
FlyAnt = flyant() #实例化蜜蜂
FlyAnt.crawl(3,4)
FlyAnt.attack()
FlyAnt.fly()
black
爬爬.....
当前位置:(3,4)
用嘴咬
爬爬.....
当前位置:(3,4)
发射尾针...
飞呀飞呀我的骄傲放纵。。
# 多重继承
class A:
name = '灭绝师太' #定义类变量
def set_age(self,age=88):
self.age = age
def set_KongFu(self,KongFu='峨眉剑法'):
self.KongFu =KongFu
def info(self):
print('name=%s,age=%d,KongFu=%s'%(A.name,self.age,self.KongFu))
class B:
name = '苏蓉蓉'
def set_age(self,age=20):
self.age = age
def loveman(self,love='楚留香'):
self.love = love
print('蓉蓉爱%s'%(self.love))
def set_KongFu(self,KongFu='易容术'):
self.KongFu = KongFu
def info(self):
print('name=%s,age=%d,loveman=%s,KongFu=%s'%(B.name,self.age,self.love,self.KongFu))
class C(A,B): #先继承A后继承B,AB若有同名的方法则A覆盖B
pass
class C2(B,A): #先继承B后继承A,AB若有同名的方法则B覆盖A
pass
class C3(B,A):
def info(self): #继承A,B且覆盖A,B中的方法info
A.info(self)
B.info(self)
print('使用第一个子类:')
CC = C()
CC.set_age()
CC.set_KongFu()
CC.loveman()
CC.info()
print('使用第二个子类:')
CC2 = C2()
CC2.set_age()
CC2.set_KongFu()
CC2.loveman()
CC2.info()
print('使用第三个子类:')
CC3 = C3()
CC3.set_age()
CC3.set_KongFu()
CC3.loveman()
CC3.info()
使用第一个子类:
蓉蓉爱楚留香
name=灭绝师太,age=88,KongFu=峨眉剑法
使用第二个子类:
蓉蓉爱楚留香
name=苏蓉蓉,age=20,loveman=楚留香,KongFu=易容术
使用第三个子类:
蓉蓉爱楚留香
name=灭绝师太,age=20,KongFu=易容术
name=苏蓉蓉,age=20,loveman=楚留香,KongFu=易容术
总结：
python中的类与对象与JAVA相比多了类的多重继承，把继承和接口融合成了一体，JAVA中之所以不允许多继承就在于要限制JAVA程序的规模，如果子类继承多个父类的话可能会造成代码规模过于庞大，不方便代码的维护。但是在python中不会发生这样的情况，因为python比JAVA更加的面向对象，python中有许多的内置函数可以使用这使得python的代码更加的简洁优美，不会造成代码量规模过于庞大，而且这也使得python语言更加的灵活多变。python中的self关键字与java中的 this有异曲同工之妙都是指的当前对象，可以用来在构造函数中给实例属性初始化。
