Java转Python之面向对象编程

快来打我* 2022-06-03 06:17 163阅读 0赞

1 class的编写与语法

class中所有函数的第一个入参必须是self命名的，相当于Java的this，只不过Java类中的方法没有显式的将this放入入参内，而python中却将self显示的声明在函数的入参里，当然函数真正被调用时self这个变量是不需要传入的。Self是Python中约定俗成的参数名名，可以换成别的命名。

class的构造器一定要是\_\_init\_\_命名的，这一点与java差别很大，Java是自己的类名。

Python的class中的成员变量是\_\_init\_\_构造的时候指定并赋值的，这一点与Java的差异是巨大的，在Java中成员变量是提前声明好的。

与\_\_init\_\_对应的销毁函数是\_\_del\_\_函数，对象被销毁时调用。

2 实例的创建没有new关键字，直接通过类名的方式来创建对象:

entityName= ClassName(param1,param2,……)

3 实例成员变量和函数的访问与java一样，对象名加“.”的方式。实例创建后可以随时添加和删除成员变量，与JS语法一样，这个是与强对象类型Java语言天壤之别的差距，Java刚转Python感觉很不理解，这算哪门子的面向对象，这明明是面向过程的。可能python的class更多的定义的是能力，是函数功能，对于成员变量是弱化的，与Java的interface更贴近一些。

getattr(obj,name\[, default\]) : 访问对象的属性。

hasattr(obj,name): 检查是否存在一个属性。

setattr(obj,name,value): 设置一个属性。如果属性不存在，会创建一个新属性。

delattr(obj,name) : 删除属性。

4内置类属性，通过所有class可以通过这些内置类获取class的相关信息

\_\_dict\_\_:类的属性

\_\_doc\_\_:类的文档（class声明的第一行）

\_\_name\_\_:类名

\_\_module\_\_:类所在的模块

\_\_bases\_\_:类的所有父类

结合1、2、3、4给出的例子：

class User:
        'This is user class'
        count=0
        def __init__(self,name,age):
            self.name=name
            self.age=age
            User.count+=1
        def showMe(self):
            print("Name: %s age: %s No. %d" %(self.name,self.age,self.count))
        def __del__(self):
            User.count -= 1
            print("%s die: " % self.name)
    
    zhangsan = User('zhangsan',21)
    zhangsan.showMe()
    lisi = User('lisi',32)
    lisi.showMe()
    print(zhangsan.count)
    zhangsan.wife='瑛姑'
    lisi.children=['小明','小美']
    print(zhangsan.wife)
    print(lisi.children)
    #内置类
    print(User.__doc__)
    
    del zhangsan.wife
    #print(zhangsan.wife)

执行结果：

Name: zhangsan age: 21 No. 1
    Name: lisi age: 32 No. 2
    2
    瑛姑
    ['小明', '小美']
    This is user class
    zhangsan die: 
    lisi die:

如果将最后一行放开会报错，因为成员变量已经被删除了！

5 Python也是自动GC的，虽然表面上跟JVM的GC效果一样，但是实现机制却完全不一样。JVM的GC是寻根，有没有被栈中指针或者句柄使用决定是否被回收；Python是引用计数设计，罗列了一些需要排查的场景，例如循环垃圾收集。

6 Python既然号称是OO的那么它也支持继承来解决代码的重用性，继承的语法是

class subClassName(parentClassA,parentClassB,…):

没错，语法中发现是多继承，也可以思考下这种继承方式下如果在父类中有重复的函数怎么办？经过实测是以class声明时继承类括号中的先后顺序决定的，左边优先级大于右边。这一点做为Java开发人员就感觉很别扭，都是父亲，根据顺序还有亲爹、养父、干爹之分……同理多继承时子类代码在调用父类函数时也要指定父类名称，这也是多继承带来的强制性要求。

多继承带来的另一个分歧来了，左边的爷爷有的函数和右边的爹有的函数，哪个优先级更高？只能通过代码来亲测下：

例子：

class A:
       def foo(self):
          print('called A.foo()')
    class B(A):
       def foo(self):
          print('called B.foo()')
    class C(A):
       def foo(self):
          print('called C.foo()')
    class D(B, C):
       pass
    
    d = D()
    d.foo()

将D继承的括号中BC的顺序交换下执行试试，将Class B的foo方法去掉后再试试，从结果看得出Python的继承顺序是先按辈分再按左右顺序的。

其他方面与Java一样，例如相同函数名先匹配子类再匹配父类；子类重写父类函数等

7 像Java所有对象都继承自Object一样，我们也可以理解为python的类也隐形的继承了一个object超类，从那个超类中继承下来了这些函数：

\_\_init\_\_( self \[,args...\] ) 构造器

\_\_del\_\_(self ) 销毁函数

\_\_str\_\_(self ) 相当于Java中的toString

\_\_cmp\_\_(self, x )比较函数

\_\_add\_\_(self, other ) 加法运算函数

8 类函数的修饰及范围。

Java中的方法分为private、protected、默认、public四种开放级别，python对函数也有范围限定，只不过不是通过修饰符来定义的，是通过函数命名规范来定义的。

\_\_function\_\_：左右各两个下划线包围起来的函数名，是系统级别的函数，例如\_\_init\_\_

\_\_function：两个下划线开头的函数名，相当于Java中的private

\_function: 一个下划线开头的函数名，相当于Java中的protected

function:默认的没有修饰符的是public的

结合5、6、7、8给出的例子：

class People :
        def __init__(self,name):
            print('This is people init')
            self.name=name
    
        def __del__(self):
            print('%s die' %self.name)
    
        def _protectedFunction(self):
            print('This function is protected')
        '''
        def __str__(self):
            return self.name
        '''
    
    
    #工人
    class Worker(People) :
        'This is Worker class'
        def __init__(self,name,job,salary):
            print('This is mother init function')
            People.__init__(self,name)
            self.job=job
            self.salary=salary
        def doJob(self,someBody):
            print('Do job for somebody %s for %d salary' %(someBody,self.salary))
        def __add__(self, other):
            return Worker(self.name+other.name,self.job+other.job,self.salary+other.salary)
        def __privateFunction(self):
            People._protectedFunction(self)
        def publicFunction(self):
            People._protectedFunction(self)
    
    #家长
    class Parent(People) :
        'This is Parent class'
        def __init__(self,name,children):
            print('This is Parent init function')
            People.__init__(self, name)
            self.children=children
        def teach(self):
            print('teach children %s' %self.children)
    
    class WorkingParent(Worker,Parent) :
        'This is WorkingParent class'
        def __init__(self,name,job,salary,children):
            print('This is WorkingParent init function')
            Worker.__init__(self, name,job,salary)
            self.children = children
        def think(self):
            print('How to balance job and children?')
    
    children=['小明','小华']
    zhangsan = WorkingParent('zhangsan','pastor',1000,children)
    zhangsan.think()
    zhangsan.teach()
    zhangsan.doJob('king')
    lisi = Worker('lisi','student',100)
    newOne = lisi+zhangsan
    newOne.doJob('newJob')
    newOne.publicFunction()
    print(newOne)

执行结果

This is WorkingParent init function
    This is mother init function
    This is people init
    How to balance job and children?
    teach children ['小明', '小华']
    Do job for somebody king for 1000 salary
    This is mother init function
    This is people init
    This is mother init function
    This is people init
    Do job for somebody newJob for 1100 salary
    This function is protected
    <__main__.Worker object at 0x000001AB16D0B128>
    zhangsan die
    lisi die
    lisizhangsan die

将People中的\_\_str\_\_注解放看，可以看到最终打印对象时发生了变化，相当于重写了Java中的toString()方法。

可以在主程序中尝试调用\_\_privateFunction()方法，会抛异常方法不存在。

还可以将People中的\_protectedFunction()方法替换成双下划线的试下

总结：Python的OO和Java的OO跨度不大，最大的区别就是多继承会带来一些变化，但是只要理解了继承的顺序使用多集成时需要注意的地方也很清晰。