java - 为什么重写在 JAVA 中的工作方式与 C++ 有所不同？

Question

我有一些 C++ 背景知识，也了解一些 Java(显然远远不够)。

当我看到 Java 或 C++ 中的覆盖行为时，它们似乎没有太大区别。在 JAVA 中给出以下示例:

class Animal{

   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal reference and object
      Animal b = new Dog(); // Animal reference but Dog object

      a.move();// runs the method in Animal class
      b.move();//Runs the method in Dog class
   }
}

在Java中，你使用基类引用，在C++中你使用基类指针，根据它指向的实例类型(基类对象实例或子类实例)，你可以实现多态性。

以上是基于你使用基类引用或指针调用实例方法，对吧？

现在我在 Java 中看到了这个例子。

What is the order of the Constructors in this Java Code?

基本上就是说如果一个基类的函数被重写了，那么在创建子类对象的过程中，连基类的初始化部分都会受到影响。请参阅我从上面的链接复制的以下解释:

new Son()
=>  
  Son._init
   =>  first every constructor calls super()
      Father._init
         Object._init
         who()  => is overridden, so prints "son" !!!!!
         tell(name) => name is private, so cannot be overridden => "father"
   who()  => "son"
   tell(name)  => "son"

为什么会这样？我的意思是这是否符合应该如何使用多态性？在初始化基类部分时，为什么要使用子类的重写函数？

在 Java 文档中 http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.5 ，我只找到这个:

“与 C++ 不同，Java 编程语言在创建新类实例期间不会指定更改的方法分派(dispatch)规则。如果调用的方法在被初始化对象的子类中被覆盖，则使用这些覆盖方法，甚至在新对象完全初始化之前。”

但我不知道背后的原因，感觉很奇怪。

有什么想法吗？

Answer 1

这是 C++ 比 Java 更努力保护您免于搬起石头砸自己脚的极少数情况之一。 (或者至少它有这样做的崇高意图。)

如果您尝试从 B 的构造函数中调用基类 B 的可重写(虚)方法 M，您很可能用任何语言搬起石头砸自己的脚。这是因为 M 很可能在派生类中被重写D，但是在构建B的时候，D还没有构建。因此，在调用 D 的构造函数之前调用 D.M。这可能意味着灾难。

因此，Java 允许这种情况发生，使用风险自负。 (如果您启用了足够多的警告，您的编译器会告诉您您的生活很危险。)

C++ 也不禁止这样做，但它稍微改变了它的行为以包含损害，可以这么说:当你从构造函数中调用虚方法时，它并没有真正将它作为虚方法调用，(使用 VMT 查找，)但它直接调用它，作为一种非虚拟方法。

(要么，要么在 B 的构造函数中，它只是使用类 B 的 VMT 而不是 D 的 VMT。现在想想，这是有道理的。但我不确定，这已经很长时间了自从我上次解决 C++ 的这种行为以来已经过去了。)