39

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.

Community
  • 1
  • 1
rgarci0959
  • 539
  • 1
  • 4
  • 8
  • 10
    Note that for classes you should use the Java standard naming convention with names like `ClassA` and `ClassB`. Names starting with lower case characters indicate variables. – Thorbjørn Ravn Andersen Dec 28 '15 at 06:17
  • 3
    "I would assume that only the `classB` constructor would be called and thus the only output would be `B`" But `classB`'s constructor prints `A`... – totymedli Dec 28 '15 at 13:53
  • @totymedli thanks for pointing that out. I had them switched – rgarci0959 Dec 28 '15 at 16:11
  • As far as I know in the world of mammals ancestor is constructed usually before its descendants.. Probably the Java original designers mimic the same behavior. – 0x90 Dec 28 '15 at 16:14
  • @ThorbjørnRavnAndersen They are also typically used for non-constructor methods. – jpmc26 Dec 28 '15 at 17:04

3 Answers3

56

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.

Pshemo
  • 122,468
  • 25
  • 185
  • 269
Aniket Thakur
  • 66,731
  • 38
  • 279
  • 289
9

Super class constructor is always called during construction process and it's guaranteed that super class construction is finished before subclass constructor is called. This is the case for most if not all the object oriented language. You could explicitly call super class constructor with parameter if you don't want to invoke the default constructor; otherwise such call is automated by compiler.

Alex Suo
  • 2,977
  • 1
  • 14
  • 22
2

There is no difference in both statements in terms of objects being constructed so you see same out put.

Just using a different reference type on left hand side while constructing same objects using new is not going to make any difference as far as object creation and constructor chaining is concerned.

Whatever difference is there among two of your statements is after objects get created.

Sabir Khan
  • 9,826
  • 7
  • 45
  • 98