What does the default constructor really do?

Question

There is something that I don't understand about the real role of the default constructor in java. In the official tutorial about object creation :

Creating Objects

All classes have at least one constructor. If a class does not explicitly declare any, the Java compiler automatically provides a no-argument constructor, called the default constructor. This default constructor calls the class parent's no-argument constructor, or the Object constructor if the class has no other parent. If the parent has no constructor (Object does have one), the compiler will reject the program.

And in the docs about the Default Constructor (§8.8.9)

8.8.9. Default Constructor

If the class being declared is the primordial class Object, then the default constructor has an empty body. Otherwise, the default constructor simply invokes the superclass constructor with no arguments.

So even the default constructor of the class Object has an empty body. And I know that the default constructor does NOT initialize fields to their default values, because it's the compiler who does that :

Default Values

It's not always necessary to assign a value when a field is declared. Fields that are declared but not initialized will be set to a reasonable default by the compiler.

What I don't understand is, if we didn't declare a constructor, what does the default constructor really do ?

Answer 1

what does the default constructor really do?

It calls super(). As per all your quotations. And does nothing else. JLS #8.8.9:

If the class being declared is the primordial class Object, then the default constructor has an empty body. Otherwise, the default constructor simply invokes the superclass constructor with no arguments.

i.e. it does nothing else. For those who believe it initializes instance variables please see JLS #12.5 where the contrary is asserted.

Answer 2

What I don't understand is, if we didn't declare a constructor, what does the default constructor really do ?

By default, if no constructor is declared, a class has a default constructor with no args.
I think that's why, by default all constructor calls super(). It follows probably the convention over configuration principle.

Whatever you declare a public constructor or you don't declare at all constructor, first instruction of the constructor is super().
That's why if you define in a class MyClass a constructor with args MyClass(String s) without keeping a constructor with no argument, constructor of MyClass subclasses cannot compile while it doesn't precise in their first instruction, the call to an existing parent constructor, in the exemple, it would be super(String ...).

Here an example :

public class MyClassWithNoArg{
  public MyClassWithNoArg(){
  }
}

MyClassWithNoArg constructor calls super() in this first instruction even if it not specified in the source code.

It is as if it is written in this way :

public class MyClassWithNoArg{
  public MyClassWithNoArg(){
     super();
  }
}

Imagine now another class MyClassWithArg:

public class MyClassWithArg{
  public MyClassWithNoArg(String s){
  }
}

And MySubclass a subclass of MyClassWithArg

public class MySubclass extends MyClassWithArg{
  public MySubclass (String s){
  }

  public MySubclass (){
  }
}

In both cases, it will not compile since as explained previously all constructors call by default the default constructor (super()) of their parent but here the parent,MyClassWithArg, has no constructor with no arg. So, it doesn't compile.

So to solve the problem, you have to call the super constructor which exists.

public class MySubclass extends MyClassWithArg{
  public MySubclass (String s){
     super(s);
  }

  public MySubclass (){
    super("");
  }
}

Now, compilation is OK.

Answer 3

In Java, if you don´t declare any constructor the compiler create a default constructor and this constructor call to super() method, that is parents constructor. And in this process, inits instance variables like no-default constructors.

Answer 4

Without constructor no one can create a object of a class. Now if programmer does not add any constructor with a class then java compiler added a constructor with that class before compilation,which is known as default constructor in java.

But if programmer adds any kind of constructor(with argument or without argument) then that becomes user defined constructor and no constructor 'll be added via java compiler.

Now question is what does constructor do.

1. allocates memory for new object
2. if user defines any other operation like initialising variable that is done.