what happens if super class doesn't have constructor and sub class has constructor that doesnot call to super class constructor by itself

Question

lets say there are two classes A and B, and B is inheriting A.

Now we have not created a constructor for A.

But on the other hand we have created a constructor for B and have not called the A class constructor.

What happens then and Why?

Edit: I created this question mainly thinking about the question in java

Answer 1

It sounds like the code you are describing is something like this:

class A {}

class B extends A {
  B() {}
}

There are two sections of the language spec relevant to the question.

Firstly, Section 8.8.7 says that if the constructor body doesn't begin with this(...) or super(...), then it implicitly starts with super(), an invocation of the superclass' no-arg constructor.

This means B effectively looks like:

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

(Try comparing the bytecode with and without the explicit super() call, you will see they are identical)

For this to compile, A would have to have a no-arg constructor.

Although it apparently has no constructors, the second relevant bit of the language spec is Section 8.8.9: when no constructors are explicitly declared, a default constructor will be implicitly declared. This has the same access modifier as the class, and take no arguments.

This means A effectively looks like:

class A {
  A() {
    super(); // call to superclass constructor because of Sec 8.8.7, that is, Object().
  }
}

(Again, try declaring this constructor explicitly and comparing the bytecode)

Such a default constructor is necessary in order for a class to invoke its superclass constructor, in order that the instance is fully initialized before use.

Answer 2

I explained the working as it would be in java

Okay, so I created the question myself as it was a little confusing at first glance. I will try to explain the answer the best I can.

what it does and why it does:

Understanding Situation: Class A is inherited by Class B. But as we haven't created a class A constructor, a default constructor is created.

Now keep in mind that a default constructor doesn't have any parameters in it.

Now as class B has a constructor when its object is created, this constructor is called. As we are not calling the superclass constructor in the subclass constructor, it calls it by default.

Keep in mind that if it calls a superclass constructor by default, it will not pass any parameters while calling that constructor. You can assume that it places a super(); on the first line of the B class constructor.

As Jonathan Rosenne states:

The Java Language Specification says "If a constructor body does not begin with an explicit constructor invocation and the constructor being declared is not part of the primordial class Object, then the constructor body implicitly begins with a superclass constructor invocation "super();", an invocation of the constructor of its direct superclass that takes no arguments.". Note end of the sentence - no arguments

Final answer: Now, as a superclass constructor is called without any parameter, and it has already created a default constructor in the superclass without any parameters, this default constructor is called by the subclass constructor.

Default class constructor does its work and gives all the variables their default values, then passes the control back to the subclass constructor and it does anything that we have mentioned in the subclass constructor.

Solving other problems by inferring this answer:

• 1.So if you have created a constructor in the superclass but it doesn't have any parameters, then you might or might not call it in the subclass constructor, the result would be the same. Either you would have to write super(); or it would be added by default at the first line of the subclass constructor.

• 2.If you have a superclass constructor that has parameters, then you must call it in the subclass constructor, else it would by default call a superclass constructor without any parameters and as we have created a parameterized constructor in the superclass, it would not have a default or a non-parameterized constructor to get called and it would result in an error of constructor not found.