Java-为什么它打印 null？

Question

public class Base {
public Base() {
    x = 0;
    bar();
}

public Base(int x) {
    this.x = x;
    foo();
}

public void foo() {
    System.out.println("Base.foo : " + x);
}

private void bar() {
    System.out.println("Base.bar:" + x.toString());
}

protected Integer x;
}

    public class Derived extends Base {
       public Derived() {
       bar();
       }
       public Derived(int x, int y) {
         super(x);
         this.y = y;
       }
       public void foo() {
         System.out.println("Derived.foo : " + x + ", " + y);
       }
       public void bar() {
         System.out.println("Derived.bar:" + x.toString() + ", " + y.toString());
       }
       private Integer y;


       public static void main(String[] args) {
        Base b = new Derived(10, 20);
      }
}

为什么它打印 "Derived.foo:" 10, nulll 而不是 20 而不是 null？ y 是 Derived 的私有变量，它被初始化为 20。它在它的范围内。那么为什么它是 null 呢？

Answer 1

因为超级构造函数首先被调用（super(x)）。这个超级构造函数调用方法 foo。然后 Derived 构造函数将 y 初始化为 20 (this.y = y)。因此，当调用 foo 时，y 尚未初始化。

在构造函数中调用可重写方法是一种不好的做法，因为正如您刚刚注意到的，它可以在部分构造的对象上调用重写方法。

Answer 2

println 来自方法 foo，该方法是从 Base 的构造函数调用的，而该构造函数是从 Derived 的构造函数调用的构造函数（通过 super）在初始化 y 之前。所以空值是预期的。

Answer 3

这样做是因为超类 (Base) 构造函数在设置 y 成员变量之前调用 Derived.foo()。

所以这是基本的操作顺序：

main(...)
Derived(10,20) (start constructor)
Base(10) (start constructor)
this.x = x
foo() (calls Derived.foo() which prints the message you see)

然后之后

this.y = y

Answer 4

如果您跟踪构造函数的调用，就会更清楚：

1. 调用 Derived(int x, int y) 构造函数
2. 调用超级构造函数 Base(int x)
3. 设置 < code>x 变量
4. 调用重写的 foo() 方法
5. 执行 println()
6. Then 设置y 变量

As您可以看到，在您尝试打印出该值后，y 变量就被设置了。这就是为什么您会看到 null 的未初始化值。

从构造函数调用可重写的方法是一个常见的错误，因为它可能允许未初始化的变量在对象完全构造之前转义。

Answer 5

当您进入超类的构造函数时，y 尚未实例化。因此，对 foo() 的调用将有一个 null y。

Answer 6

它由超级构造函数调用触发的 Derived.foo() 打印出来，然后用 20 进行初始化。所以在打印时它仍然为空。

Answer 7

所有答案确实都是正确的，但下次您可以在打印某些内容的函数中放置一个断点。
然后，您可以简单地检查调用堆栈并通过阅读正在调用的部分来跟踪代码。

这样您就可以发现 y 不会被初始化。

祝你好运！
罗尔

Answer 8

因为在基类构造函数中调用 foo() 时 y 尚未初始化。

链条消失了
主要->导出(x,y) ->基数(x) ->初始化 x, foo()。但是，因为您在 Derived 内部启动调用，该调用会覆盖 foo()，所以衍生的 foo() 实际上是由解释器执行的。