java和c++中的动态方法调度

Question

在这个 C++ 程序中，

#include<iostream>
using namespace std;

class Base
{

    public:

    Base()
    {
        cout<<"\n\nBase ctr";
        fun();
    }  

    virtual void fun()
    {
        cout<<"\n\nBase's fun()";
    }
};

class Derived : public Base
{
    public:

    Derived()
    {
        cout<<"\n\nDerived ctr";
        fun();
    }

    virtual void fun()
    {
        cout<<"\n\nDerived's fun()";
    }
};
    int main()
    {
        Derived obj;
        return 0;
    }

当使用 Derived 类对象从 Base 类的构造函数调用虚函数时，会调用 Base 的类 fun()，

输出::
基础点击率

Base 的 fun()

派生的ctr

Derived 的 fun()

原因解释here 但是

在这个java程序中，

class Base
{
    Base()
    {
        System.out.println( "\n\nBase ctr" );
        fun();
    }
    void fun()
    {
        System.out.println( "\n\nBase's fun()" );
    }
}

class Derived extends Base
{
    int a=1;

    Derived()
    {
        System.out.println( "\n\nDerived ctr a = "+a );

        a=8;
        fun();
    }

    void fun()
    {
       System.out.println( "\n\nDerived's fun() a = "+a );
    }

    public static void main(String args[])
    {
       Derived obj = new Derived();
    }
}

输出是 ::
基础点击率

Derived 的 fun() a = 0

导出 ctr a = 1

Derived 的 fun() a = 8

这里调用了派生类fun()，所以constraint应用于c++程序，不适用于JAVA程序。为什么？

Answer 1

这两种语言采用不同的方法进行动态调度。在 C++ 中，它只会分派给完全构造的对象。这是通过在构造过程中更改对象的类型来处理的，因为层次构造函数的不同级别开始正在执行。另一方面，Java 甚至在启动最基础的构造函数之前就认为对象是最派生的类型。

Java 方法的问题在于，它实际上可能在尚未构造的对象上执行代码。考虑派生类型有一个初始化为 X 的字段，并且它在方法中被访问/更新。在基础对象上调用该方法将在构造函数初始化之前访问该成员。

无论如何，您都应该避免在任何一种语言的对象的构造函数或析构函数中调用虚函数。

---

示例：

public class Base {
   public final int x;
   public Base() { 
      x = foo();
   }
   int foo() { return 1; }
}
public class Derived extends Base {
   public final int y;
   public Derived() {
      y = 2;
   }
   int foo() { return y; }
}
Derived d = new Derived();
assert( d.x == d.y );                      // Can this ever fail?

在这段代码中，我们有 2 个最终的int，代码看起来很简单，可以推理。 assert 会失败吗？