Prerequisite – Constructors in Java
Constructor chaining is the process of calling one constructor from another constructor with respect to current object.
Constructor chaining can be done in two ways:
- Within same class: It can be done using this() keyword for constructors in same class
- From base class: by using super() keyword to call constructor from the base class.
Constructor chaining occurs through inheritance. A sub class constructor’s task is to call super class’s constructor first. This ensures that creation of sub class’s object starts with the initialization of the data members of the super class. There could be any numbers of classes in inheritance chain. Every constructor calls up the chain till class at the top is reached.
Why do we need constructor chaining ?
This process is used when we want to perform multiple tasks in a single constructor rather than creating a code for each task in a single constructor we create a separate constructor for each task and make their chain which makes the program more readable.
Constructor Chaining within same class using this() keyword :
75 5 The Default constructor
Rules of constructor chaining :
- The this() expression should always be the first line of the constructor.
- There should be at-least be one constructor without the this() keyword (constructor 3 in above example).
- Constructor chaining can be achieved in any order.
What happens if we change the order of constructors?
Nothing, Constructor chaining can be achieved in any order
default 5 80
NOTE: In example 1, default constructor is invoked at the end, but in example 2 default constructor is invoked at first. Hence, order in constructor chaining is not important.
Constructor Chaining to other class using super() keyword :
Calling parameterized constructor of base Calling parameterized constructor of derived
Note : Similar to constructor chaining in same class, super() should be the first line of the constructor as super class’s constructor are invoked before the sub class’s constructor.
Alternative method : using Init block :
When we want certain common resources to be executed with every constructor we can put the code in the init block. Init block is always executed before any constructor, whenever a constructor is used for creating a new object.
init block default init block 10
NOTE: If there are more than one blocks, they are executed in the order in which they are defined within the same class. See the ex.
init second default init second 10
This article is contributed by Apoorva singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to firstname.lastname@example.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
- Constructor getDeclaredAnnotations() method in Java with Examples
- Constructor getParameterCount() method in Java with Examples
- Constructor isVarArgs() method in Java with Examples
- Constructor isSynthetic() method in Java with Examples
- Constructor getGenericExceptionTypes() method in Java with Examples
- Constructor hashCode() method in Java with Examples
- Constructor getGenericParameterTypes() method in Java with Examples
- Constructor toString() method in Java with Examples
- Constructor getName() method in Java with Examples
- Constructor equals() method in Java with Examples
- Constructor getDeclaringClass() method in Java with Examples
- Constructor toGenericString() method in Java with Examples
- Implementing our Own Hash Table with Separate Chaining in Java
- Constructor Overloading in Java
- Copy Constructor in Java