python面向对象编程

1.类：

 

class MyClassA:
    pass

ma = MyClassA()

用python写个类就这么简单，当然这个类啥也不能干。

 

2.成员函数

 

class MyClassA:
    def tell(self):
        print('This is MyClassA')

ma = MyClassA()

ma.tell()

可以看到，比普通函数多了一个self，用于对对象的变量引用。类似c++的this指针，不过这个用"."而不是"->"访问变量。

 

尽管多了一个self，但同C++和java比，代码显然更干净整齐。

3.特殊函数

 

class MyClassA:
    def tell(self):
        print('This is MyClassA')
    def __init__(self):
        print('MyClassA init')
    def __del__(self):
        print('MyClassA del')

>>> ma = MyClassA()
MyClassA init
>>> ma = 0
MyClassA del
>>> 

 

可以看到__init__类似于构造函数，__del__类似于析构函数。也可以看到，由于python是动态语言，一旦对象没有引用，就会被析构。

4.对象的变量和类的变量

 

class MyClassA:
    classNum = 0
    def tell(self):
        print('This is MyClassA')
    def __init__(self):
        self.num = 0
        MyClassA.classNum += 1
        print('MyClassA init')
    def __del__(self):
        MyClassA.classNum -= 1
        print('MyClassA del')
    def setNum(self,num):
        self.num = num
    def getNum(self):
        return self.num
    def printClassCount():
        print(MyClassA.classNum)

>>> ma = MyClassA()
MyClassA init
>>> mb = MyClassA()
MyClassA init
>>> ma.setNum(3)
>>> mb.setNum(5)
>>> mb.getNum()
5
>>> ma.getNum()
3
>>> ma = MyClassA()
MyClassA init
MyClassA del
>>> MyClassA.printClassCount()
1
>>> mb = MyClassA()
MyClassA init
MyClassA del
>>> MyClassA.printClassCount()
2
>>> ma = MyClassA()
MyClassA init
MyClassA del
>>> MyClassA.printClassCount()
2
>>> 
num是对象的变量，classNums是类的对象。前者类似C++的成员变量，后者类似C++的类的静态变量。类的变量是所有对象共享的，不需要对象，可以直接用“类名.变量名”访问。而对象的变量是每个对象一个拷贝，必须通过对象访问。
通过上面还可以看到，对象指向一个新建对象，会先init再del。
上面的printClassCount()类似C++的静态函数。就像静态函数没有this指针一样，它也没有self变量。

5.继承

 

class MyClassB(MyClassA):
    def tell(self):
        print('This is MyClassB')

括号里就是父类，python的继承很简单吧。

 

 

class MyClassB(MyClassA):
    def tell(self):
        MyClassA.tell(self)
        print('This is MyClassB')

可以像上面这样调用父类的函数。

 

子类中不能有跟父类同名的类的变量，就算声明一个同名变量，其实际跟父类是一个变量。

6.封装

面向对象的三大特点（封装，继承，多态），对于C++和JAVA等静态语言，封装完就定了。而python作为动态语言，可以随时往对象里加东西，当然我们不推荐这样做。

例如上面的ma对象，只要ma.new_item = 100,就给ma添加了一个新成员变量。

7.多态

由于pytho是动态语言，每个对象都知道自己类型，本身就能实现多态，好像也没法不多态。

 

ma = MyClassA()
mb = MyClassB()
mc = ma #mc是MyClassA
mc = mb #mc是MyClassB

看上去，动态比多态更变态吧。 也模仿来个孙悟空派他的猴子猴孙打闹天宫的场景：