Java 继承-尝试了解它是如何工作的

我有两门课：

public class A
{
    protected int _x;

    public A(){  
        _x = 1;  
    }
    public A(int x) {  
        _x = x;  
    }

    public void f(int x) {  
        _x += x;  
    }

    public String toString() {  
        return "" + _x;  
    }
}

public class B extends A
{
    public B() {  
        super(3);  
    }
    public B(int x) {
        super.f(x);
        f(x);
    }

    public void f(int x)
    {
        _x -= x;
        super.f(x);
    }
}

主要内容：

publicstaticvoidmain（字符串[]args）
{
A[]arr=新的A[3]；
arr[0]=新的B（）；
arr[1]=新的A（）；
arr[2]=新的B（5）；
对于（int i=0；i 1
而言，
arr
数组中的第二个元素是
A
类型的对象，该对象是使用无参数构造函数初始化的

arr[1] = new A();
...
public A(){  
    _x = 1;  
}

public A(int x) {  
    _x = x;  
}

对该对象调用
f（2）
。这将是
A#f（int）方法（即
A
类中的
f（）
）

因此，将2与1相加，即3


似乎您指的是第一个元素。第一个元素是用no arg
B
构造函数初始化的

arr[0] = new B();
...
public B() {  
    super(3);  
}

调用
A
构造函数的

arr[1] = new A();
...
public A(){  
    _x = 1;  
}

public A(int x) {  
    _x = x;  
}

将
\ux
设置为
3
。在该对象上调用
f（2）
时，由于多态性和后期绑定，它会调用
B
中的
f（int）
方法

public void f(int x)
{
    _x -= x;
    super.f(x);
}

这将删除2到3，即1。但是
super.f（x）
将调用
A
版本的
f（int）
将2添加回
\ux
，即
\ux
的最终结果是3。
第一个元素是
B
的一个实例。调用
super（3）的默认构造函数
\ux
将等于3。循环的第一次迭代将是
arr[0]。f（2）；
这将调用
B
中的
f
方法。这将使
\ux
减少2，因此3-2=1。然后
f
的超级被称为->1+2=3。
我指的是第一个元素，因为arr[0]=新的B（）是它的类型B@user2976270当然，它是一个
B
实例。你让它的构造函数调用超级构造函数，而方法调用超级方法。那么，为什么它在类中进入f而不是B类呢？@user2976270它首先通过
B
的
f（）
方法，然后是
super.f（x）
哪个调用
A的实现。你的意思是调用默认构造函数哪个调用super（2）。B中的默认构造函数调用super（3），不是吗？