zoukankan      html  css  js  c++  java
  • python

    面向对象三大特性: 封装、继承、多态
      python中默认就支持了多态。所以不用关注多态的知识点。我们主要的知识点就放在封装和继承上,封装和继承是基本的知识。

    1、创建简单的类和对象。

    •   比较简单的类和对象调用。
    class foo():
        def foo_test(self):
            print ('This is foo.foo_test')
    f = foo()
    f.foo_test()
    # This is foo.foo_test
    # 先创建了一个foo类,这个类中只有一个foo_test方法。
    # f = foo() 是把foo类实例化成了一个f对象。
    # f.foo_test() 是f调用了foo_test方法。这是在执行foo类中的foo_test方法。
    •   向类中的普通方法传递参数
    class foo():
        def foo_test(self,arg):
            print (arg)
    f = foo()
    f.foo_test('test_arg')
    # test_arg
    # 向foo_test方法传递arg的参数。
    •   搞清楚类中的self是谁
    class foo():
        def foo_test(self,arg):
            print (self,arg)
    
    f = foo()
    print (f)
    f.foo_test('test1')
    
    f2 = foo()
    print (f2)
    f2.foo_test('rr3r3')
    
    # <__main__.foo object at 0x03894110>
    # <__main__.foo object at 0x03894110> test1
    # <__main__.foo object at 0x038941F0>
    # <__main__.foo object at 0x038941F0> rr3r3
    #

        在执行 print (f)的时候,时可以看到f这个对象的内存地址的。当f.foo_test('test1')掉用foo_test时,我们在foo_test函数内也打印self。这时的self内存地址和f这个对象的内存地址一致。所以说明self是调用这个方法的对象。

        同样的在f2这个对象的内存地址也说明了self。实例化的对象,self就是哪个对象。


    2、在类中创建方法

    •   构造方法

        构造方法就是当实例化一个对象时,就默认执行的方法。

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

        在这例子中,当执行f = foo()时,就会执行foo类中的__init__方法。这个__init__方法就是构造方法。

        其中f.test是通过对象想类中的方法传递参数。

        最后我们调用了foo_test方法,并向他传递了arg_参数。


    3、面向对象三大特性 - 封装

    •   使用构造方法封装默认参数
    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 男 最爱大保健

        在这个例子中,我们就将name,age,gender这些相同的参数通过构造方法封装到了foo这个类中。所以在之后的show中才能直接调用。

    4、面向对象三大特性 - 继承

    •   最简单的继承
    class foo():
        def show(self):
            print ('foo.show')
    class foo_1(foo):
        def foo_1_show(self):
            print ('foo_1.foo_1_show')
    test_obj = foo_1()
    test_obj.show()
    # foo.show

        foo_1这个类在定义的时候就继承了foo类。所以在执行test_obj.show()方法时,执行了父类中的show方法,因为foo_1这个类中没有show方法。

    •   在子类中执行父类的方法
    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
    •   重写父类中的方法
    class foo():
        def show(self):
            print ('foo.show')
    class foo_1(foo):
        def foo_1_show(self):
            print ('foo_1.foo_1_show')
        def show(self):
            print ('foo_1.show')
    test_obj = foo_1()
    test_obj.show()
    # foo_1.show

        我们在foo_1定义了与父类相同名称的方法,这时父类的方法就不生效了。就会执行子类中的show方法。

    •   多继承,对象查找方法时的顺序

        首先是当继承了多个父类时,我们要先从左到右的顺序查找。

    class f2():
        def show(self):
            print ('f2.show')
    class f1(f2):
        def show1(self):
            print ('f1.show')
    class ff1():
        def show(self):
            print ('ff1.show')
    class sun(f1,ff1):
        pass
    
    obj = sun()
    obj.show()
    # f2.show

    这里说的从左到右的查找顺序是说,在继承的时候class sun(f1,ff1): 。这行代码中f1在ff1左边。

     在说一种情况

    在这样的继承中查找方法的顺序应该是,先在f1、f2中查找。如果没有在从ff1中查找,如果ff1中也没有再找最后的根f3。

    class f3():
        def show(self):
            print ('f3.show')
    class f2(f3):
        def show1(self):
            print ('f2.show')
    class f1(f2):
        def show1(self):
            print ('f1.show')
    class ff1(f3):
        def show(self):
            print ('ff1.show')
    class sun(f1,ff1):
        pass
    
    obj = sun()
    obj.show()
    # ff1.show
  • 相关阅读:
    Java实现 蓝桥杯VIP 算法训练 一元三次方程
    Java实现 蓝桥杯VIP 算法训练 乘法表
    Java实现 蓝桥杯VIP 算法训练 矩阵加法
    Java实现 蓝桥杯VIP 算法训练 一元三次方程
    Java实现 蓝桥杯VIP 算法训练 平方计算
    Java实现 蓝桥杯VIP 算法训练 平方计算
    Java实现 蓝桥杯VIP 算法训练 平方计算
    Java实现 蓝桥杯VIP 算法训练 乘法表
    Java实现 蓝桥杯VIP 算法训练 乘法表
    监管只是压倒网盘业务的一根稻草,但不是主要原因(答案只有一个:成本!)
  • 原文地址:https://www.cnblogs.com/qikang/p/8667049.html
Copyright © 2011-2022 走看看