Why is super class constructor always called

Question

I have the following 2 classes

public class classA {
    classA() {
        System.out.println("A");
    }
}

class classB extends classA {
    classB() {
        System.out.println("B");
    }
}

and then running

1

classA c = new classB();

or

2

classB c = new classB(); 

always gives

A
B

Why is this happening? At first glance, in either scenario, I would assume that only the classB constructor would be called and thus the only output would be

B

but this is clearly wrong.

Answer 1

That is how Java works. The constructors of the parent classes are called, all the way up the class hierarchy through Object, before the child class's constructor is called.

Quoting from the docs:

With super(), the superclass no-argument constructor is called. With super(parameter list), the superclass constructor with a matching parameter list is called.

Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.

If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of Object. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.