Python构造方法和方法的重写重载

时间:2018-02-03 10:57:02   来源:deng笨蛋   阅读:
一、Python构造方法 

先看一个例子,如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def init(self,num):
        self.num=num

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py==========
>>> test=A()
>>> test.init(10)
>>> test.num
10
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这种方法是在类中自行定义了一个初始化函数并对num赋值,但是对该值赋值需要在对象实例化之后,通过实例化的对象调用初始化方法。因此,就初始化操作而言显得不够灵活,可以通过构造方法解决这个问题。与普通方法不同,当一个对象创建时,在类的构造方法就会被调用,对实例化对象进行初始化。构造方法的定义和使用如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def __init__(self):
        self.num=10
        self.data=20
    def output(self):
        print(self.num,'  ',self.data)

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py==========
>>> test=A()
>>> test.output()
10    20
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15



二、方法的重写和重载

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def output(self):
        print('This is a test case for class A')

class B(A):
    pass

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py==========
>>> testA=A()
>>> testA.output()
This is a test case for class A
>>> testB=B()
>>> testB.output()
This is a test case for class A
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

实际上在B中相当于是继承类A的output方法,所以在B中没有重写该方法的情况下,输出的结果与A一致,实现继承父类方法的重写如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def output(self):
        print('This is a test case for class A')

class B(A):
    def output(self):
        print('This is a test case for class B')       

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py==========
>>> testA=A()
>>> testA.output()
This is a test case for class A
>>> testB=B()
>>> testB.output()
This is a test case for class B
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

对于子类方法的重写,就是对与父类相同的方法名进行函数体的改写,从而表现出父类与子类的不同特性。但是,对于初始化操作而言,不能直接改写,否则可能出错。

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def __init__(self):
        self.flag=1
    def write(self):
        if self.flag==1:
            self.flag=0
            print('Write file success')
        else:
            print('Write file fail')

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py========== 
>>> testA=A()
>>> testA.write()
Write file success
>>> testA.write()
Write file fail
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

这个类的作用是进行文件的写操作,但是只能写一次,当第二次进行写操作时报错。若是有另外一个类继承该类,并进行了类的初始化定义,那么结果就会出错,如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def __init__(self):
        self.flag=1
    def write(self):
        if self.flag==1:
            self.flag=0
            print('Write file success')
        else:
            print('Write file fail')
class B(A):
    def __init__(self):
        self.s='Test case for class B'
    def output(self):
        print(self.s)

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py========== 
>>> testB=B()
>>> testB.output()
Test case for class B
>>> testB.write()
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    testB.write()
  File "C:\Users\Mr_Deng\Desktop\test.py", line 7, in write
    if self.flag==1:
AttributeError: 'B' object has no attribute 'flag'
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

在这个例子中类B继承了父类A,但是在B中却重新定义了构造方法,这样使得B的实例对象,尽管拥有了父类A的write方法,但是由于没有flag变量的初始化,在调用父类的write方法时报错。为了解决这个问题,可以使用未绑定的超类构造方法,如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def __init__(self):
        self.flag=1
    def write(self):
        if self.flag==1:
            self.flag=0
            print('Write file success')
        else:
            print('Write file fail')
class B(A):
    def __init__(self):
        A.__init__(self)
        self.s='Test case for class B'
    def output(self):
        print(self.s)

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py========== 
>>> testB=B()
>>> testB.write()
Write file success
>>> testB.output()
Test case for class B
>>> 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

在子类B中使用B.init(self)方法,将当前实例作为self参数提供给未绑定方法,使得子类也拥有了与父类初始化中相同的属性和方法。当然,也可以不使用未绑定方法而使用新版中的super方法,如下:

# _*_ coding:utf-8 _*_
__metaclass__=type
class A:
    def __init__(self):
        self.flag=1
    def write(self):
        if self.flag==1:
            self.flag=0
            print('Write file success')
        else:
            print('Write file fail')
class B(A):
    def __init__(self):
        super(B,self).__init__()
        self.s='Test case for class B'
    def output(self):
        print(self.s)

运算结果:
==========RESTART: C:\Users\Mr_Deng\Desktop\test.py========== 
>>> testB=B()
>>> testB.write()
Write file success
>>> testB.write()
Write file fail
>>> testB.output()
Test case for class B
>>> 
上海尚学堂python人工智能感谢原文作者分享,原文地址:http://blog.csdn.net/u010480899/article/details/52807039
分享:0

电话咨询

客服热线服务时间

周一至周五 9:00-21:00

周六至周日 9:00-18:00

咨询电话

021-67690939
15201841284

微信扫一扫