面向对象编程

Posted 2020-10-29 qikang

 

最简单的类文件

 

class foo():
    def t4(self,arg):
        print (self,arg)
f = foo()
print (f)
f.t4(‘test1‘)
# <__main__.foo object at 0x039841F0> #f 的self
# <__main__.foo object at 0x039841F0> test1
# <__main__.foo object at 0x03984250> # f2的self
# <__main__.foo object at 0x03984250> rr3r3
f2 = foo()
print (f2)
f2.t4(‘rr3r3‘)

 

从执行结果可以看出，self就是f。也就是那个对象实例化了类，self就是这个对象，也就是调用的的对象。

 

我们也可以通过对象想类中的方法传递参数。

class foo():
    def t4(self,arg):
        print (self,self.t3,self.r5,arg)
f = foo()
print (f)
f.t3 = ‘23‘ #向类中传值，每次调用这个类中的方法都要传值。
f.r5 = ‘re3‘ #向类中传值。把r5变量封装在f这个对象中。
f.t4(‘test1‘)
print (‘--------‘)
f2 = foo()
print (f2)
f2.t3 = ‘12‘ #向类中传值
f2.r5 = ‘hahe‘ #向类中传值
f2.t4(‘rr3r3‘)
# <__main__.foo object at 0x03704650>
# <__main__.foo object at 0x03704650> 23 re3 test1
# --------
# <__main__.foo object at 0x03704670>
# <__main__.foo object at 0x03704670> 12 hahe rr3r3

 

封装：

构造方法

　　构造方法是在实例化一个类时，被实例化对象调用。

class foo():
    def __init__(self): # 在实例化foo对象时，这个__init__内部方法是默认执行的。这个init就是构造方法。
        self.test = ‘error‘
        print (‘internal month‘)
    def t4(self,arg):
        print (self.test)
        print (arg)
f = foo()
f.t4(‘arg_‘)
# internal month
# error
# arg_

 

class foo():
    def __init__(self,name,age,gender): # 把初始化时的，name,age,gender都封装到类中。
        self.name = name
        self.age = age
        self.gender = gender

    def show(self,arg):
        print (self.name,self.age,self.gender,arg)

xiaoming = foo(‘小明‘,‘10‘,‘男‘)
xiaoming.show(‘上山去砍柴‘)
xiaoming.show(‘开车去东北‘)
xiaoming.show(‘最爱大保健‘)

zhangsan = foo(‘张三‘,‘10‘,‘男‘)
zhangsan.show(‘上山去砍柴‘)
zhangsan.show(‘开车去东北‘)
zhangsan.show(‘最爱大保健‘)

# 小明 10 男 上山去砍柴
# 小明 10 男 开车去东北
# 小明 10 男 最爱大保健
# 张三 10 男 上山去砍柴
# 张三 10 男 开车去东北
# 张三 10 男 最爱大保健

 

继承：

　　是类继承类。

　　最简单的继承

class foo():
    def show1(self):
        print (‘foo.show1‘)
    def show2(self):
        print (‘foo.show2‘)

class foo2(foo):
    def show_1(self):
        print (‘foo2.show1‘)

test_obj = foo2()
test_obj.show_1()
test_obj.show1()

　　此处foo2继承foo，所以在test_obj.show1()时可以调用父类(foo)的方法。

 

　　重写父类的方法

　　

class foo():
    def show1(self):
        print (‘foo.show1‘)

class foo2(foo):
    def show1(self):
        print (‘foo2.show1‘)

test_obj = foo2()
test_obj.show1()
# foo2.show1

 

　　执行父类中的方法

class foo():
    def show1(self):
        print (‘foo.show1‘)

class foo2(foo):
    def show_1(self):
        super(foo2,self).show1() #有两种调用父类中的方法,推荐用这种方法
　　　　　# foo.show1(self) 
        print (‘foo2.show1‘)

test_obj = foo2()
test_obj.show_1()
# foo.show1
# foo2.show1