Introduction to Constructor in Java
Constructors in Java are special types of methods that are used to initialize the objects of the class. Constructors are called at the time of object creation of class. Just like methods, although they hold a set of lines of code they are quite different from them. Constructors have the same name as the Java class but it does not have any return type. In Java, a new() keyword to used to create an object and every time a new object is created and one constructor is called. The constructor is called after the memory is allocated to the object. At the time of object creation, constructors are used to initializing the values of class variables to either default or the desired ones.
If the user does not create any constructor in the program, Java itself creates a default constructor for it and assign default values to the different objects like for numeric default value is 0, for a character (‘\0’) and reference variables as null. Like methods, constructors can be overloaded, i.e. a single class can have many constructors if all of them have a unique signature.
The basic syntax of Constructor in Java is given below:
Syntax
public class Student() // name of the class
{
. . . .
. . . .
. . . .
Student() // this is Constructor with the same name of class
{
. . .
. . .
}
new Student(); // object creation and value initialization
}
In the above syntax, Student() is the name of the constructor which is the same as the name of the class and the objects in Java are created using the keyword new.
How does Constructor work in Java?
To understand the working of Constructors in Java, let’s take an example given below:
4.8 (4,120 ratings)
View Course
Code
public class Student()
{
int rollno;
String name;
Student(int rollno, String name)
{
this.rollno = rollno;
this.name = name;
}
public static void main(String[] args)
{
Student st = new Student(12, ‘Ananya’);
System.out.println(“Student name = ”+ st.name + “Student rollno = ”+st.rollno);
}
}
Output
In the above example, we have instance variables (class variables). roll no and name and st Is the name of the object created of the class Student. When the object st is created, it invokes the constructor Student and initializes the class variables with the rollno value as 12 and name as ‘Ananya’ otherwise default values like 0 for rollno and null for the name will get assigned to the variables. Hence after assigning the values and printing them, the student name is printed as Ananya and Student rollno as 12.
Types of Constructors in Java
There are 2 types of constructors in Java based on parameters:
1. Non-parameterized / No arguments Constructor
When we do not pass arguments in the constructor, that constructor is known as a non- parameterized or no-argument constructor. When the programmer does not define any constructor in the Java program then the Java compiler itself adds a constructor in it, known as default constructor which provides default values to the object like 0, null, etc. The default constructor is no special type of constructor but falls in the category of no arguments constructor.
Example (Default Constructor)
Code
public class Hello()
{
String name;
void display() //method to display name the value of variables
{
System.out.println(“name is” +name);
}
}
public class HelloMain()
{
public static void main(String[] args)
{
Hello h1 = new Hello();
h1.display();
}
}
Output:
In the above example, this is no constructor defined by the programmer, so the compiler will treat this program as:
Code
public class Hello()
{
String name;
Hello() //default constructor created by compiler
{
name = null
}
void display()
{
System.out.println(“name is” +name);
}
}
public class HelloMain()
{
public static void main(String[] args)
{
Hello h1 = new Hello();
h1.display();
}
}
Example (Non-Parameterized Constructor)
Code
public DemoProgram() // class
{
DemoProgram() // constructor with no arguments
{
System.out.println(“Hello this is just an example of no-arg constructor”);
}
public static void main(String[] args)
{
new DermoProgram();
}
}
Output:
As in the above example, for the constructor DemoProgram() there are no arguments passed, only the message is printed and hence it is known as No-argument constructor.
2. Parameterized Constructor
Parameterized constructors are those constructors in which we pass the arguments or parameters. In this constructor, values are passed at the time of object creation.
Example (Parameterized Constructors)
Code
public class Animal()
{
int legs;
String sound;
Animal(int legs, String sound) // parameterized constructor
{
this.legs = legs; // values with get initialize of what is passed while object crea-this.sound = sound; // tion, i.e. (4, “bow bow”)
}
void display() // method to display the values
{
System.out.println(“Legs are ”+legs+“Sound is ”+sound);
}
}
class AnimalPlanet()
{
Public static void main(String[] args)
{
Animal an = new Animal(4, “bow bow”);
an.display();
}
}
Output:
In the above example value 4 is assigned to the legs and the string “bow bow” is assigned to the sound in constructor Animal. So when the method display is called both the values get printed in the output.
Important Points to Remember
- Every class has a constructor whether the programmer creates it or not.
- The constructor name should be the same as the class name.
- The constructor has no return type, unlike methods.
- this() and super() keyword must be the first statement in a constructor.
- Like methods, constructors can be overloaded.
- Constructors can not be overridden.
- One constructor can invoke another constructor of the same class using the keyword this().
- Access specifiers/ modifiers can be applied before the name of the constructor to declare the scope of it in a class.
- In Java, a constructor can never be static, final, abstract and Synchronized.
Conclusion
Constructors play an important role when it comes to working with Java programming language. One must need to understand the full concepts of Constructor, various types of Constructors, Constructor Chaining, the super() keyword used to call the parent constructor to work according to the specific scenario. Though working with constructors in Java is very easy like working with methods but there are few points specific to constructors that should be learned thoroughly.
Recommended Article
This is a guide to the constructor in java. Here we discuss how constructor works in java along with the types and examples with appropriate code implementation. you can also go through our suggested articles to learn more-
