本章主要内容

• 类与对象
• 定义和使用类
• 类的属性和方法
• 类的继承
• 类的方法重载

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有异曲同工之妙都是指的当前对象，可以用来在构造函数中给实例属性初始化。