Java 继承中的“this”关键字是如何工作的？

Question

在下面的代码sn-p中，结果真的很混乱。

public class TestInheritance {
    public static void main(String[] args) {
        new Son();
        /*
        Father father = new Son();
        System.out.println(father); //[1]I know the result is "I'm Son" here
        */
    }
}

class Father {
    public String x = "Father";

    @Override
    public String toString() {
       return "I'm Father";
    }

    public Father() {
        System.out.println(this);//[2]It is called in Father constructor
        System.out.println(this.x);
    }
}

class Son extends Father {
    public String x = "Son";

    @Override
    public String toString() {
        return "I'm Son";
    }
}

结果是

I'm Son
Father

为什么“this”在Father构造函数中指向Son，而“this.x”在Father中指向“x”字段。 “this”关键字是如何工作的？

我知道多态的概念，但是[1]和[2]之间不会有区别吗？当 new Son() 被触发时，内存中发生了什么？

Answer 1

默认情况下，Java 中的所有成员函数都是多态的。这意味着当您调用 this.toString() 时，Java 使用动态绑定来解析调用，调用子版本。当您访问成员 x 时，您访问的是当前作用域的成员（父亲），因为成员不是多态的。

Answer 2

这里发生了两件事，让我们来看看：

首先，您要创建两个不同的字段。看一下（非常孤立的）字节码块，您会看到：

class Father {
  public java.lang.String x;

  // Method descriptor #17 ()V
  // Stack: 2, Locals: 1
  public Father();
        ...
    10  getstatic java.lang.System.out : java.io.PrintStream [23]
    13  aload_0 [this]
    14  invokevirtual java.io.PrintStream.println(java.lang.Object) : void [29]
    17  getstatic java.lang.System.out : java.io.PrintStream [23]
    20  aload_0 [this]
    21  getfield Father.x : java.lang.String [21]
    24  invokevirtual java.io.PrintStream.println(java.lang.String) : void [35]
    27  return
}

class Son extends Father {

  // Field descriptor #6 Ljava/lang/String;
  public java.lang.String x;
}

重要的是第 13、20 和 21 行；其他代表System.out.println(); 本身，或隐含的return;。 aload_0 加载 this 引用，getfield 从对象检索字段值，在这种情况下，从 this。您在这里看到的是字段名称是合格的：Father.x。在Son 的一行中，您可以看到有一个单独的字段。但是Son.x 从未使用过；只有Father.x 是。

现在，如果我们删除 Son.x 并添加这个构造函数会怎样：

public Son() {
    x = "Son";
}

先看一下字节码：

class Son extends Father {
  // Field descriptor #6 Ljava/lang/String;
  public java.lang.String x;

  // Method descriptor #8 ()V
  // Stack: 2, Locals: 1
  Son();
     0  aload_0 [this]
     1  invokespecial Father() [10]
     4  aload_0 [this]
     5  ldc <String "Son"> [12]
     7  putfield Son.x : java.lang.String [13]
    10  return
}

第 4、5 和 7 行看起来不错：this 和 "Son" 已加载，字段设置为 putfield。为什么Son.x？因为JVM可以找到继承的字段。但需要注意的是，尽管该字段被引用为Son.x，但JVM找到的字段实际上是Father.x。

那么它是否给出了正确的输出？不幸的是，没有：

I'm Son
Father

原因是语句的顺序。字节码中的第 0 行和第 1 行是隐式的super(); 调用，因此语句的顺序是这样的：

System.out.println(this);
System.out.println(this.x);
x = "Son";

当然会打印"Father"。为了摆脱这种情况，可以做一些事情。

可能最干净的是：不要在构造函数中打印！只要构造函数还没有完成，对象就没有完全初始化。您正在假设，由于 printlns 是构造函数中的最后一个语句，因此您的对象是完整的。正如您所经历的，当您有子类时，情况并非如此，因为超类构造函数总是会在您的子类有机会初始化对象之前完成。

有些人认为这是构造函数本身概念的缺陷；在这个意义上，有些语言甚至不使用构造函数。您可以改用init() 方法。在普通方法中，你有多态的优势，所以你可以在Father引用上调用init()，然后Son.init()被调用；而new Father() 总是创建一个Father 对象。 （当然，在 Java 中你仍然需要在某些时候调用正确的构造函数）。

但我认为你需要的是这样的：

class Father {
    public String x;

    public Father() {
        init();
        System.out.println(this);//[2]It is called in Father constructor
        System.out.println(this.x);
    }

    protected void init() {
        x = "Father";
    }

    @Override
    public String toString() {
        return "I'm Father";
    }
}

class Son extends Father {
    @Override
    protected void init() {
        //you could do super.init(); here in cases where it's possibly not redundant
        x = "Son";
    }

    @Override
    public String toString() {
        return "I'm Son";
    }
}

我没有它的名字，但试试看。它会打印

I'm Son
Son

那么这里发生了什么？您最顶层的构造函数（Father 的构造函数）调用 init() 方法，该方法在子类中被覆盖。由于所有构造函数首先调用super();，因此它们有效地执行超类到子类。因此，如果最顶层的构造函数的第一次调用是init();，那么所有的初始化都发生在任何构造函数代码之前。如果您的 init 方法完全初始化了对象，那么所有构造函数都可以使用已初始化的对象。而且由于init()是多态的，它甚至可以在有子类的情况下初始化对象，这与构造函数不同。

请注意init() 是受保护的：子类将能够调用和覆盖它，但其他包中的类将无法调用它。这比public 略有改进，也应该考虑用于x。

Answer 3

如前所述，您不能覆盖字段，只能隐藏它们。见JLS 8.3. Field Declarations

如果该类声明了一个具有特定名称的字段，则该字段的声明被称为隐藏了超类和该类的超接口中具有相同名称的任何和所有可访问的字段声明。

在这方面，隐藏字段不同于隐藏方法 (§8.4.8.3)，因为在字段隐藏中没有区分静态字段和非静态字段，而区分静态和非静态字段方法隐藏中的静态方法。

如果隐藏字段是静态的，则可以使用限定名称 (§6.5.6.2) 或使用包含关键字 super (§15.11.2) 的字段访问表达式或转换为超类类型来访问隐藏字段。

在这方面，隐藏字段类似于隐藏方法。

一个类从它的直接超类和直接超接口继承超类和超接口的所有非私有字段，这些字段都可以被类中的代码访问，并且不会被类中的声明隐藏。

您可以使用super 关键字从Son 的范围内访问Father 的隐藏字段，但相反的情况是不可能的，因为Father 类不知道它的子类。

Answer 4

虽然可以覆盖方法，但可以隐藏属性。

在您的情况下，属性x 是隐藏的：在您的Son 类中，您无法访问Father 的x 值，除非您使用super 关键字。 Father 类不知道 Son 的 x 属性。

相反，toString() 方法被覆盖：将始终被调用的实现是实例化类之一（除非它不覆盖它），即在你的情况下 Son，无论变量的类型(Object, Father...)。

Answer 5

多态方法调用仅适用于实例方法。您始终可以使用更通用的引用变量类型（超类或接口）引用对象，但在运行时，唯一根据实际对象（而不是引用类型）动态选择的东西是实例方法 不是静态方法。非变量。只有被覆盖的实例方法会根据真实对象的类型动态调用。

所以变量x 没有多态行为，因为它不会在运行时被动态选择。

解释你的代码：

System.out.println(this);

Object 类型为Son，因此将调用toString() 方法的Overridden Son 版本。

System.out.println(this.x);

这里的对象类型不在图片中，this.x 在Father 类中，所以将打印x 变量的Father 版本。

查看更多信息：Polymorphism in java

Answer 6

这是一种专门用于访问私有成员的行为。所以 this.x 查看为父亲声明的变量 X，但是当您在父亲的方法中将此作为参数传递给 System.out.println 时 - 它会根据参数的类型查看要调用的方法 - 在您的案例儿子。

那么如何调用超类方法呢？使用super.toString()等

从父亲它无法访问儿子的 x 变量。

Answer 7

这通常称为阴影。注意你的类声明：

class Father {
    public String x = "Father";

和

class Son extends Father {
    public String x = "Son";

当您创建Son 的实例时，这会创建两个名为x 的不同 变量。一个x 属于Father 超类，第二个x 属于Son 子类。根据输出，我们可以看到，当在Father 范围内时，this 访问了Father 的x 实例变量。因此该行为与“this 指向的内容”无关；这是运行时搜索实例变量的结果。它只会在类层次结构中向上 搜索变量。一个类只能引用自身及其父类的变量；它不能直接访问其子类中的变量，因为它不知道任何关于其子类的信息。

要获得你想要的多态行为，你应该只在Father中声明x：

class Father {
    public String x;

    public Father() {
        this.x = "Father"
    }

和

class Son extends Father {
    public Son() {
        this.x = "Son"
    }

本文讨论了您所遇到的行为：http://www.xyzws.com/Javafaq/what-is-variable-hiding-and-shadowing/15。