子类调用超级构造函数，超级构造函数调用子类方法而不是它自己的方法

Question

我将从一个代码示例开始：

class A {
    public A() {
        f(); //When accessed through super() call this does not call A.f() as I had expected.
    }

    public void f() {} //I expect this to be called from the constructor.
}

class B extends A {
    private Object o;

    public B() {
        super();
        o = new Object(); //Note, created after super() call.
    }

    @Override
    public void f() {
        //Anything that access o.
        o.hashCode(); //Throws NullPointerException.
        super.f();
    }
}

public class Init {
    public static void main(String[] args) {
        B b = new B();
    }
}

这个程序会抛出一个

NullPointerException

。当对象 b 进入其超类

A

的构造函数并调用被类 B 重写的方法

f()

时，会调用

B.f()

，而不是我期望的

A.f()

。

我认为超类不应该知道它是否被子类化，但是类肯定可以使用它来判断它是否被子类化？这背后的原因是什么？如果我真的希望调用

A.f()

而不是

B.f()

，有什么解决方法吗？

提前致谢。

---

后续问题：

感谢您的回答。我现在明白为什么会这样，但这里有一个后续问题。也许我错了，但子类型化的一个原则是超类型不应该知道它已被子类型化。这种“机制”让类知道它是否已被子类化。考虑这个代码示例：

class A {
    private boolean isSubclassed = true;

    public A() {
        f(); //A.f() unsets the isSubclassed flag, B.f() does not.
        if(this.isSubclassed) {
            System.out.println("I'm subclassed.");
        } else {
            System.out.println("I'm not subclassed.");
        }
    }

    public void f() {
        this.isSubclassed = false;
    }
}

class B extends A {
    public B() {
        super();
    }

    @Override
    public void f() {}
}

public class Init {
    public static void main(String[] args) {
        new B(); //Subclass.
        new A();
    }
}

该程序的输出是：

I'm subclassed.
I'm not subclassed.

这里

A

知道它已经被子类化了。不知道是谁干的，但这并不重要。这是如何解释的呢？我是不是被误导了？

Answer 1

出现

NullPointerException

是因为当您构造 B 的实例时，会调用父构造函数（在 A 中）。此构造函数调用

f()

方法，但由于对象的实际类型是 B，因此调用 B 中重写的

f()

方法。

@Override
public void f() {
    //Anything that access o.
    o.hashCode(); //Throws NullPointerException as o has not been initialised yet
    super.f();
}

这里的教训是永远不要在构造函数中调用可以被子类覆盖的方法。

Answer 2

这就是为什么你不应该从构造函数中调用非私有方法。除了将方法设为私有之外，没有其他解决方法。

Answer 3

这就是override隐藏自己方法的原因。在

f()

类构造函数中调用

super

时，它隐藏了

super

类方法调用。实际上它是调用

subclass

重写的方法。

 class A{
 public A() {
    f(); // It call the subclass overided method.
  }
 // This method is hide due to override.
  public void f() {
    } 
 }

class B extends A {
// This method is called before constructor where Object o is Null, hence you
// got NullPointerExcetion.
@Override
public void f() {
    // Anything that access o.
    o.hashCode(); // Throws NullPointerException.
    super.f();
 }
}

Answer 4

class A {
    public A() {
             System.out.println(1);
         f(); 
             // where super(),this will be called by subclass ,but subclass's o is null 
    }
    public void f() {
        System.out.println(4);
    }
}