Java - 为什么重写方法被调用两次（或者至少它看起来像这样）？

Question

The below has this output.

Hello World!
main.ConstructedDerivedClass:6.0
main.ConstructedDerivedClass:6.0

public class ConstructedDerivedClass extends ConstructedBase {

    private static final double version = 6.0;

    public static void main(String[] args) {

        System.out.println("Hello World!");

        ConstructedDerivedClass derivedClass = new ConstructedDerivedClass();
    }

    public ConstructedDerivedClass() {
        showMyAttributes();
    }

    @Override
    protected void showMyAttributes() {
        System.out.println(this.getClass().getName() + ":" + version);
    }  
}

public class ConstructedBase {

    private static final double version = 15.0;

    public ConstructedBase() {
        showMyAttributes();
    }

    protected void showMyAttributes() {
        System.out.println(this.getClass().getName() + ":" + version);
    }
}

I would expect it to just display one line, that of the child class (ConstructedDerivedClass). But instead it print's out twice.I know in general you should avoid calling overriden methods from a constructor, but I wanted to see for myself how was this working.

Actually, I get why version is '6.0' on both lines - since field is being declared static of course static fields are initialized first. But still don't get why two lines.

Any guidance would be appreciated.

Answer 1

This is because when you write

public ConstructedDerivedClass() {
    showMyAttributes();
}

The compiler actually places a call to super default constructor in byte code so it's equivalent to

public ConstructedDerivedClass() {
    super();        
    showMyAttributes();
} 

Answer 2

When an object is instantiated, it makes an implicit, no-args super-constructor call to its parent class before running its own constructor.

You can imagine that there is this line ALWAYS in your constructors:

public MyClass() {
    super(); //If this line is not here, it is implicit.
    //rest of the code
}

You can override this by providing your own explicit, any-args super-constructor call, but it must be the first line of the method.

public MyClass() {
    super(1, "Hello Word", null); //written explicitly, no other super-constructor code will run
    //rest of the code
}

Which can be useful when the superclass does not have a no-args constructor defined.