Table of Contents
Basics of Java
Java, with its remarkable and dynamic features, has emerged as one of the most sought-after choices of developers for large-scale programming of web applications. It is a user-friendly language with a wide range of extraordinary features. Its compatibility with all the operating systems is the rich API has made it popular across the globe. The language offers robust community support and excellent documentation services. Java has a suite of solid development tools.
Constructors in Java
The constructors in Java are used to initialize the state of the object. Just like methods, constructors also contain a group of statements or instructions that are to be executed while an object is created.
Why do we need a constructor in Java?
Let us consider a Box. If the box is assumed to be a class, it may have several variables such as width, length and height. When an object is to be created, the box class will have no defined values for its dimensions. At the time of creating new objects, the constructors assign values to the variables of the class. The assignment of values can either be done using default Java constructors or explicitly by the parameters passed by the programmer.
When is a Constructor Invoked?
A minimum of one constructor is invoked each time when an object is created using the new() keyword. This constructor provides initial values to the class’s data members. In general, a constructor is called when a new object or instance is created.
Constructor Overloading in Java
The process of defining multiple constructors of the same class is referred to as Constructor overloading. However, each constructor should have a different signature or input parameters. In other words, constructor overloading in Java is a technique that enables a single class to have more than one constructor that varies by the list of arguments passed. Each overloaded constructor is used to perform different task in the class.
The Java compiler identifies the overloaded constructors on the basis of their parameter lists, parameter types and the number of input parameters. Hence, the constructors that are overloaded should have different signatures. A constructor’s signature contains its name and parameter types. An ambiguity issue arises when two of the class constructors have an identical signature.
The compiler fails to differentiate between the two and hence returns an error notification. When constructors with different signatures are overloaded, the compiler determines the constructor to be invoked based on the number of input parameters of the objects.
Use of Constructor Overloading
As construction overloading enables the creation of the object of a specific class in several ways, it is most commonly used in Java programs based on the requirement of the programmer. With the use of constructor overloading, objects can be initialized with different data types.
Consider that an object with three class instance variables is taken as an example where a particular value is to be assigned to the second instance variable and the other variables are to be assigned default values. This can be accomplished by the declaration of multiple constructors according to the different signatures in the constituent class.
Example Code for the Implementation of Constructor Overloading in Java
Let us consider a program in which an Employee class has three constructors. Based on the values passed, each of the three is invoked to initialize an object.
Use of this Reference in Java
All instance methods and constructors welcome an implicit parameter called ‘this’, which is used to refer to the current object. The current object is that object on which the method is invoked. We can use the ‘this’ reference to refer to the current object within any constructor or method. The ‘this’ reference can be used, like any other object references, to access instance methods, constructors and variables, within the method or constructor’s body.
Few important scenarios where the ‘this’ reference is used are:
- When the names of the parameters are different from the instance variable names
- When a reference is to be passed to the current object and a parameter to another method
- When a constructor is to be invoked from another constructor.
The this() reference arguments must match the arguments of the target constructor in this case. The this() function must be the first statement within the constructor. In special cases such as complexity of initialization routine, this function can be used in the duplicate code elimination in multiple constructors.
Learn Software Development Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs or Masters Programs to fast-track your career.
Benefits of Constructor Overloading in Java
The key advantages of making use of constructor overloading while writing Java programs are:
- The constructor overloading enables the accomplishment of static polymorphism.
- The class instances can be initialized in several ways with the use of constructor overloading.
- It facilitates the process of defining multiple constructors in a class with unique signatures.
- Each overloaded constructor performs various tasks for specified purposes.
- Constructor overloading in Java refers to the use of more than one constructor in an instance class. However, each overloaded constructor must have different signatures.
- For the compilation to be successful, each constructor must contain a different list of arguments.
- The list of parameters includes sequence and the types of input arguments.
- Two constructors in a class with the same list of parameters is not feasible in Java.
If you’re interested to learn more about full stack software development , check out upGrad & IIIT-B’s Executive PG Programme in Software Development – Specialisation in Full Stack Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.