C++和java中多态机制的异同

以前我有个错误的观点：即使在C++和java中多态性的实现机制可能不同，但它们的表现形式应该相同，也就是说如果代码结构相同，那么执行结果也应该相同。可惜事与愿违，事情并不总是你想象中的那样子。（在看下文以前，你最好先考虑一下这个问题，你有什么看法呢？）

首先本文不讨论面向对象编程的基本概念，如封装、继承和数据抽象等，这方面的资料现在应该多如牛毛，只是稍微提一下多态性的概念。根据Bjarne Stoustrup的说法，多态性其实就是方法调用的机制，也就是说当在编译时无法确定一个对象的实际类型时，应当能够在运行时基于对象的实际类型来决定调用的具体方法（动态绑定）。

我们先来看一下在C++中的函数调用方式：

Ø 普通函数调用：具体调用哪个方法在编译时间就可以决定（通过查找编译器的符号表），同时在使用标准过程调用机制基础上增加一个表示对象身份的指针（this指针）。

Ø 虚函数调用：函数调用依赖于对象的实际类型，一般地说，对象的实际类型只能在运行时间才能确定。虚函数一般要有两个步骤来支持，首先每一个类产生出一堆指向虚函数的指针，放在表格中，这个表格就叫虚函数表（virtual table）；然后每一个类对象（class object）会添加一个指向相关虚函数表（virtual table）的指针，通常这个指针叫做vptr。

在java中又是如何的呢？恩，区别还是满大的。在java虚拟机中，类实例的引用就是指向一个句柄（handle）的指针，而该句柄（handle）其实是一对指针：其中一个指针指向一张表，该表格包含了对象的方法列表以及一个指向类对象（表示对象类型）的指针；另一个指针指向一块内存地址，该内存是从java堆中为对象的数据而分配出来的。

唔，你要说了，好象差不多嘛，不是都要维护一张函数表吗？别急，让我们先看一下例子，这样你就能更好的理解它们之间的区别到底有多大了。

下面是C++和java的例子，不看后面的答案，你能够正确说出它们的执行结果吗？

例1：C++

class Base
{
    public: Base(){
        init();
    }

    virtual ~Base() {}

    public: virtual void do_init(){
        init();
    }

    protected: virtual void init(){
        cout << "in Base::init()" << endl;
    }
};

class Derived : public Base
{
    public: Derived(){
        init();
    }

    protected: void init(){
        cout << "in Derived::init()" << endl;
    }
};

int main(int argc, char* argv[])
{
    Base* pb;
    pb = new Derived();
    delete pb;
    return 0;
}

例2：java

class Base
{
    public Base(){
        init();
    }

    protected void init(){
         System.out.println("in Base::init()");
    }

    public void do_init(){
        init();
    }
}

class Derived extends Base
{
    public Derived(){
        init();
    }

    protected void init(){
        System.out.println("in Derived::init()");
    }
}

public class Test
{
    public static void main(String[] args){
        Base base = new Derived();
    }
}

例1的执行结果是：
in Base::init()
in Derived::init()

例2的执行结果是：
in Derived::init()
in Derived::init()

看了结果后，你是马上顿悟呢抑或是处于疑惑中呢？ok,我们来分析一下两个例子的执行过程。

首先看一下例1（C++的例子）：
1. Base* pb; 只是声明，不做什么。
2. pb = new Derived();
    1) 调用new操作符，分配内存。
    2) 调用基类（本例中是Base）的构造函数
    3) 在基类的构造函数中调用init()，执行程序首先判断出当前对象的实际类型是Base（Derived还没构造出来，当然不会是Derived），所以这里调用的是Base::init()。
    4) 调用派生类（本例中是Derived）的构造函数，在这里同样要调用init()，执行程序判断出当前对象的实际类型是Derived，调用Derived::init()。
3. delete pb; 无关紧要。

例2（java的例子）的执行过程：
1. Base base = new Derived();
    1) 分配内存。
    2) 调用基类（本例中是Base）的构造函数
    3) 在基类的构造函数中调用init()，执行程序首先判断出当前对象的实际类型是Derived（对，Derived已经构造出来，它的函数表当然也已经确定了）所以这里调用的是Derived::init()。
    4) 调用派生类（本例中是Derived）的构造函数，在这里同样要调用init()，执行程序判断出当前对象的实际类型是Derived，调用Derived::init()。

明白了吧。java中的类对象在构造前（调用构造函数之前）就已经存在了，其函数表和对象类型也已经确定了，就是说还没有出生就已经存在了。而C++中只有在构造完毕后（所有的构造函数都被成功调用）才存在，其函数表和对象的实际类型才会确定。所以这两个例子的执行结果会不一样。当然，构造完毕后，C++与java的表现就都一样了，例如你调用Derived::do_init()的话，其执行结果是：in Derived::init()。

个人认为，java中的多态实现机制没有C++中的好。还是以例子说明吧：
例子3：C++
class Base
{
    public: Base(){
        init();
    }
    virtual ~Base() {}
    protected: int value;
    virtual void init(){
        value = 100;
    }
};

class Derived : public Base
{
    public: Derived(){
        init();
    }
    protected: void init(){
        cout << "value = " << value << endl;
        // 做一些额外的初始化工作
    }
};

int main(int argc, char* argv[])
{
    Base* pb;
    pb = new Derived();
    delete pb;
    return 0;
}

例4：java
class Base
{
    public Base(){
        init();
    }
    protected int value;
    protected void init(){
        value = 100;
    }
}

class Derived extends Base
{
    public Derived(){
        init();
    }

    protected void init(){
        System.out.println("value = " + value);
        // 做一些额外的初始化工作
    }
}

public class Test
{
    public static void main(String[] args){
        Base base = new Derived();
    }
}

例3的执行结果是：value = 10

例4的执行结果是：value = 0 value = 0

从以上结果可以看出，java例子中应该被初始化的值（这里是value）没有被初始化，派生类根本不能重用基类的初始化函数。试问，如果初始化要在构造时完成，并且初始化逻辑比较复杂，派生类也需要额外的初始化，派生类是不是需要重新实现基类的初始化函数呢？这样的面向对象方法好不好呢？欢迎大家讨论。