为什么我的子类构造函数没有被调用？

Question

我有这个继承结构:

public abstract class Mom {
    int dummy;
    Mom() {
        dummy = 0;
    }
    Mom(int d) {
        this();
        dummy = d;
    }
}
public class Kid extends Mom {
    String foo;
    Kid() {
        super();
        foo = "";
    }
    Kid(int d) {
        super(d);
    }
}
// ...
Kid kiddo = new Kid(10);
// kiddo.foo == null !

我的无论证的构造函数Kid从未被调用过!这是我的预期:

1. new Kid(10) → Kid#Kid(int)
2. super(d) → Mom#Mom(int)
3. this()→ Kid#Kid()// doh !!
4. super() → Mom#Mom()

是否可以Mom调用无论Kid证的构造函数？
我猜它不是,我将添加一个抽象的方法[1] init(),Mom它将调用并且Kids 必须覆盖.
但我只是想知道确切的原因,如果可能的话,证明为什么要调用子类'构造函数的例子是一个坏主意(即使子类'构造函数确实调用super()).

// in Mom:
protected abstract void init();
public Mom() {
    dummy = 0;
    init();
}

// in Kid:
@Override
protected abstract void init() {
    foo = "";
}

Answer 1

我安排这些的方式,所以你不需要调用每个构造函数.

public abstract class Parent {
    final int dummy;

    Parent () {
        this(0);
    }
    Parent (int d) {
        dummy = d;
    }
}

public class Kid extends Parent {
    final String foo = "";

    Kid() {
    }

    Kid(int d) {
        super(d);
    }
}

使用final确保每个字段都设置一次.

从构造函数中调用任何可覆盖的方法被认为是不好的做法,因此使构造函数可以覆盖,这是一个坏主意.

this()调用同一个类的构造函数,因为构造函数不遵循继承(静态方法也不遵循)

new Kid(10) --> Kid#Kid(int)
super(d) --> Mom#Mom(int)
this() --> Mom#Mom()

构造函数执行此操作,否则您有多次调用同一构造函数的危险,并且无法保证最终方法只设置一次.