java - 继承 - 尝试理解它是如何工作的

Question

我有这两个类(class):

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);
    }
}

主要:

public static void main(String [] args)
{
    A[] arr = new A[3];
    arr[0] = new B();
    arr[1] = new A();
    arr[2] = new B(5);

    for(int i=0; i<arr.length; i++)
    {
        arr[i].f(2);
        System.out.print(arr[i] + " ");
    }
}

我试图理解为什么第一次打印后结果是 3 而不是 1一开始，Class A 空构造函数被调用，因此 _x = 1比 B 类的 f(int x) 调用 _x = _x - 2 所以 _x = -1 并在调用 Super 之后.f(x) _x = _x + x ==> 1

Answer 1

arr 数组中的第二个元素是一个 A 类型的对象，它是使用无参数构造函数初始化的

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

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

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

因此，你将 2 加 1，即。 3.

<小时/>

你的意思似乎是第一个元素。第一个元素使用无参数 B 构造函数

进行初始化

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

调用A构造函数

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

将_x设置为3。当您在此对象上调用 f(2) 时，由于多态性和后期绑定(bind)，它会调用 B 中的 f(int) 方法。

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

这将删除 2 到 3 个，即。 1. 但是 super.f(x) 将调用 A 的 f(int) 版本，并将 2 添加回 _x ，即。 _x的最终结果是3。