为什么sysout(upper class)在将下层类分配给上层类之后调用下层类的toString？

Question

我有两个类 A 和 B，而 B 是 A 的子类型：

public class A {
    private String stringVar;

    public A()  {
        stringVar = "";
    }

    public String getStringVar() {
        return stringVar;
    }

    public void setStringVar(String str) {
        this.stringVar = str;
    }

    @Override 
    public String toString()  {
        return getStringVar();
    }
}

B 类：

public class B extends A {
    private int intVar;

    public B()  {
        intVar = 0;
    }

    public int getIntVar() {
        return intVar;
    }

    public void setIntVar(int intVar) {
        this.intVar = intVar;
    }

    @Override
    public String toString()  {
        return super.toString() + " " + getIntVar();
    }
}

正如您在下面的 main 方法中看到的，我将 b 分配给 a。现在“a”无法调用 b 的方法，这一点很清楚，因为我现在使用的是 A 类型的实例。但当调用 toString 时，它的行为类似于 B。好奇的是，我本来期望的是字符串a。为什么会这样呢？

public class Main {

    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        b.setIntVar(200);
        b.setStringVar("foo");
        a = b;
        System.out.println(a);
    }
}

Answer 1

因为a指向B的实现。
并且被声明为A。

因此B的行为。并且A的方法可见。

要使用B方法，请像这样

((B) a).getIntVar();

思考它，

Object o = new FancyObject();

当编译时，仅接受对象方法，即使它是具有很多方法的FancyObjcet。

要在 o 上使用 FancyObject 的方法，请这样做。

Object o = new FancyObject();
(FancyObject o).fancyMethod();

引用“因为我现在使用 A 类型的实例”，您仍在使用 B 类型的实例。您可以看到它就像升级了 b 一样，但它是同一个实例。

图片从另一个网站交叉链接，图片中有制作人员，如果这违反规则，那么有人可以自由编辑我答案的这一部分。

Answer 2

这是继承/多态性和重写方法的本质。

重写的方法将在运行时根据对象实际类型而不是引用类型确定。

因此a.toString()实际上是b.toString()，因为它是在运行时确定的。

http://download.oracle.com/javase/tutorial/java/IandI /覆盖.html

Answer 3

您需要理解的概念是引用和对象之间的区别。

a 是一个引用（在本例中为局部变量），它首先指向 A 类型的对象，然后指向 B 类型的对象。

编译器知道它必须是 A 类型（或其子类型），因此它可以安全地调用 A 定义的所有方法，但它们将在实际对象上调用，而不是在 a。

Answer 4

这就是多态性：a 持有的对象具有静态类型 A，但它仍然是动态类型 B 的对象。因此动态调度选择重写 B 中定义的 toString()。

Answer 5

这正是 Java 运行时多态性的工作原理。重要的是运行时的实际类型。您所做的就是获取对 A 的引用并将其指向 B 的实例。您已经更改了 a 指向的事物的类型。

尝试

a = (A)b;

Answer 6

不，B 重写了 A 的 toString 方法，因此如果一个对象是 B 的实例，那么当您调用其 toString 方法时，您将获得该实例具有的任何方法。一般来说，如果您有一个对象并调用其方法，则调用的方法是实例中的方法，而不是变量类型中的方法。唯一的例外是静态方法。

在 C++ 中，情况并非如此。所调用的方法是变量类型之一（如果存在），除非您通过将方法设为虚拟来显式选择上述行为。

Answer 7

这在 OOP 中称为运行时多态性。