What is the actual use of the default constructor in java?

Question

I have read in many sources and books that constructor is used to initialise the fields when an object is created. I have also read that JVM provides a default constructor if I don't mention one. What is the purpose of a constructor if it is not required to initialise the fields like the one I have mentioned below?

I also understand that a constructor without parameter is required as it is necessary during object creation when an argument is not passed (when programmer-defined constructors with parameters exists).

Is it necessary for JVM to provide a constructor which is actually not required?

 public class test {
        int a;
        public test() { 
       //this constructor is useless

    }
public static void main(String[] args)
{ 
  test ob= new test();
  System.out.println(ob.a); 
//this prints 0 which means a constructor is not required in intialising `a`
}
}

A constructor like test() makes sense if the programmer defines it since there could be other constructors which takes argument. But why is it necessary for JVM to provide one when no constructor is declared by the programmer?

I have already tested and proved that initialising a field doesn't require constructor.

Also what does the default constructor look like?

I believe the question has an answer here: http://stackoverflow.com/questions/4488716/java-default-constructor — Bajal, Feb 15 '16 at 13:53
The answer is in your code example. Without a constructor this line would make no sense: `new test();`. You are calling a constructor here. — Ihor Romanchenko, Feb 15 '16 at 13:59
I agree but I am not able to digest it. Does JVM add something extra to my constructor during the run-time? — Mathews Mathai, Feb 15 '16 at 14:03
Technically you can create a class without a constructor via bytecode manipulations. But it will cause a failure on an attempt to create such objects because JVM has to call an init method after memory allocation. You can find some details here: http://stackoverflow.com/questions/29478139/is-it-valid-to-have-a-jvm-bytecode-class-without-any-constructor — Ihor Romanchenko, Feb 15 '16 at 14:10

score 4 · Accepted Answer · edited Aug 09 '17 at 10:59

4

The problem is that while you know the default constructor doesn't do anything in this example, in future the constructor might do something even if you don't realise it is and you might not be able to re-compile everywhere the code is used reliably. So the safest, simplest thing to do is to always call a constructor which might change in the future and let the JIT optimise away the constructor if it doesn't actually do anything.

The byte code always calls a contructor, whether you provide one or not. When you compile code which uses the default constructor it cannot assume the constructor doesn't do anything useful as you can add something to it later to do something useful. e.g.

Say you change

public class Test {
    int a;

    // public Test() { //this constructor does nothing
}

to

public class Test {
    int a;
    final List<String> strings = new ArrayList<>();

    // public Test() { //this constructor does something now.
}

or

public class ServerTest {
    final List<String> strings = new ArrayList<>();
}

public class Test extends SuperTest {
   int a;
   // the default constructor has to call super();
}

The constructor now initialised the strings field. You can change this class without having to re-compile everywhere it is used and say, hey, my constructor now does something useful, you should call it now.

edited Aug 09 '17 at 10:59

Wilfred Hughes

29,846
15
139
192

answered Feb 15 '16 at 14:03

Peter Lawrey

525,659
79
751
1,130

Well, it makes sense when the programmer defines it. – Mathews Mathai Feb 15 '16 at 14:04
I get it. It's again something similar over-riding that's taking place. right? – Mathews Mathai Feb 15 '16 at 14:05
@MathewsMathai even if the developer doesn't define it, the default constructor does something in the second example. – Peter Lawrey Feb 15 '16 at 14:05
Is the default constructor of the type Object ? – Mathews Mathai Feb 15 '16 at 14:06
@MathewsMathai I have added another example where the default constructor is needed. A constructor doesn't have a type. – Peter Lawrey Feb 15 '16 at 14:08
By type I meant, is it Class Object Constructor since Object is the highest in inheritance? – Mathews Mathai Feb 15 '16 at 14:12
Constructors are not first class objects. They are just like methods and are not part of the class hierarchy. You can have a lambda which refers to a constructor and it will be a member of the functional interface it is implementing and Object. eg. `Test::new` – Peter Lawrey Feb 15 '16 at 14:16
Okay. I think that's sums up the answer. Thanks a lot. – Mathews Mathai Feb 15 '16 at 14:18
@Gimby I have re-worked this. The JVM can optimise the constructor away. – Peter Lawrey Feb 15 '16 at 14:30

ewanc · Answer 2 · 2016-02-15T14:10:05.110

3

The reason the JVM adds a default constructor if you haven't provided one is down to inheritance. Say for example you have 3 classes (A, B & C) in which B extends A and C extends B. Now when you instantiate C it will call the constructor of C and also the constructors of B and A. If a constructor was missing in one or more of these classes then the instantiation would fail. So having the compiler automatically add a default constructor avoids error like this. You may not need to actually do any work in your constructor, but it's required for the JVM to instantiate the object.

edited Feb 15 '16 at 14:10

answered Feb 15 '16 at 13:58

ewanc

1,284
1
12
23

This again creates a doubt. If I create a constructor without parameters that is something similar to the default one(probably), and don't mention `super();` ,it still calls the super class constructor. – Mathews Mathai Feb 15 '16 at 14:01
Yeah, the super constructor is always called implicitly when an object is instantiated. This will happen all the way up to Object level. You can specify explicitly to call a super constructor but it's not necessary unless you want to call a constructor other than the default one. – ewanc Feb 15 '16 at 14:05

pleft · Answer 3 · 2016-02-15T13:53:10.533

1

The constructor(s) (both default and custom one(s)) is not only used to initialize the fields of an object but also to initialize the object itself even if it has no fields at all. Calling the constructor, JVM allocates memory for this object and creates its reference.

edited Feb 15 '16 at 13:53

answered Feb 15 '16 at 13:51

pleft

7,567
2
21
45

But what does the constructor do? .. I have mentioned nothing in the constructor. – Mathews Mathai Feb 15 '16 at 13:52
How else without calling a constructor (custom or default) would you assign a new object of class `test` to the variable `ob` in your code? – pleft Feb 15 '16 at 13:56
How does it work exactly since I have mentioned no code in it? – Mathews Mathai Feb 15 '16 at 13:58
And yes I can create an object using deserialization which actually doesn't use a constructor? – Mathews Mathai Feb 15 '16 at 13:58
`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.` For more you can read here: http://docs.oracle.com/javase/tutorial/java/javaOO/objectcreation.html – pleft Feb 15 '16 at 14:03

score 1 · Answer 4 · 2016-02-15T14:41:39.130

1

It is the compiler, and not JVM, who inserts a default constructor on absence.
A default constructor is needed because the constructor of the base class needs to be called from a constructor.
The default constructor looks like:
```
public Test() {
    super();
}
```

edited Feb 15 '16 at 14:41

answered Feb 15 '16 at 14:07

score 0 · Answer 5 · answered Feb 15 '16 at 14:03

Here while you are creating the object new test(), here parenthesis states the default constructor of object test.After creating the object,if you didnot give any constructor the default constructor is constructed by jvm.so after construction of your object first call goes to your default constructor.

score 0 · Answer 6 · answered Feb 15 '16 at 14:07

The default constructor is a no argument constructor called automatically by the compiler when you haven't defined any constructor. Anyway, a constructor as the one you defined, can be also called a default constructor. It basically calls the superclass' constructor making use of the super() method. So the default constructor called automatically would be something like:

public ClassName(){

super();

}

score 0 · Answer 7 · edited Apr 17 '18 at 15:33

Java's Compiler creates a Default Constructor if no other constructor is defined for the class.

But why?

The compiler's job is to chain the Subclass's constructor to the Super Class(ultimately Object class). It's not the Compiler's work to give a default constructor to your class therefore Java is doing it for you.

To do the chaining, it first checks if there is any constructor in the class, if yes it will add super() to that constructor.

If there is no constructor idefined in the class in order for the compiler to do a proper chaining, Java adds a default constructor and a call to super() into it.

Why ?

Because every class is a subclass of an Object class (directly or indirectly), it will inherit an object class, to do so the said Object class must be fully initialised. This is done by the default constructor.

What is the actual use of the default constructor in java?

7 Answers7

Related