为什么向上转换 ab.a + ab.b 会产生结果 1 和 1.0？

Question

我完全不明白我们是如何设法在 class A 中调用不带参数的构造函数的。在这个特定的例子中向上转型是如何工作的？当我们产生 A ab = bb; 时 ab 究竟指的是什么？

public class A {
    public Integer a;
    public Float b;

    public A() {
        a = 1;
        b = 1.0f;
    }

    public A(Integer x) {
        a = 2;
        b = 2.0f;
    }

    public int f(long x) {
        return 3;
    }

    public int f(double x) {
        return 4;
    }

}

public class B extends A {
    public int a;

    public B(float x) {
        a = 5;
    }

    public int f(int x) {
        return 6;
    }

    public int f(float x) {
        return 7;
    }

    public int f(double x) {
        return 8;
    }

}

public class M {
    public static void main(String[] args) {
        A aa = new A(1);
        System.out.println(aa.a + " " + aa.b);// OUT: [ 2 ] [2.0]

        int ret = aa.f(aa.b);
        System.out.println(ret); // OUT: [ 4 ]

        B bb = new B(6);
        A ab = bb;
        System.out.println(bb.a); // OUT: [ 5 ]
        System.out.println(ab.a + " " + ab.b);// OUT: [ 1 ] [1.0]

        ret = bb.f(1);
        System.out.println(ret); // OUT: [ 6 ]

        ret = ab.f(1.0f);
        System.out.println(ret); // OUT: [ 8 ]

        ret = ab.f(aa.a);
        System.out.println(ret); // OUT: [ 3 ]

        ret = bb.f(aa.b);
        System.out.println(ret); // OUT: [ 7 ]

    }
}

Answer 1

When we produce A ab = bb; what exactly ab refers to?

它引用bb，但作为A，即只能调用A中定义的方法和属性。没有构造新对象。您可以通过检查 System.out.println(bb == ab); 来查看，它将计算为 true。这个概念被称为 attribute- or field-hiding.

这也是为什么 ab.a returns 1 的原因，因为 A 中的属性 a（类型 Integer）被访问。另一方面，如果访问 bb.a，则会在 B 中获得属性 a（ob 类型 int），它被初始化为 [=26] =].请记住，如果您构造 B，总是会显式或隐式调用 JLS, §12.5.

中定义的超类构造函数

为什么向上转换 ab.a + ab.b 会产生结果 1 和 1.0？

Why upcasted ab.a + ab.b produce result 1 and 1.0?

java

downcast

upcasting