Constructor Program in Java
Constructor Program in Java
In Java, a constructor is a piece of code that is used to create an object. A constructor is called implicitly when an object is created in Java using the new keyword. A constructor looks like an instance method. However, a constructor and an instance method are two different things. A Java constructor is often regarded as a special type of method in Java. Constructor program in Java tells about how to use constructors in a program. Constructors always have the same name as the name of the class. Whenever a new object is created in Java, the constructor initializes that object. A class may or may not contain more than one constructor. The following rules must be followed to define a constructor in Java
1) Constructor name and class name should always match.
2) No return type should be given to a Java constructor.
3) Keywords like synchronized, static, native, final, and abstract should not be used with a Java constructor. However, access specifiers like private, protected, public can be used with a constructor.
Constructor Program in Java
The following program demonstrates how to create an array and display its elements on the console.
FileName: ConstructorExample.java
public class ConstructorExample
{
// Constructor
ConstructorExample()
{
// print statement
System.out.println("Inside the constructor of the class ConstructorExample. ");
}
public static void main(String argvs[])
{
// creating two objects obj of the class ConstructorExample
ConstructorExample obj1 = new ConstructorExample();
ConstructorExample obj2 = new ConstructorExample();
}
}
Output:
Inside the constructor of the class ConstructorExample. Inside the constructor of the class ConstructorExample.
Explanation: We see that there are two statements in the output but only one print statement in the code. This is because the calling of a constructor is dependent upon the number of times the objects are created. In the code, we have used the keyword new twice. Thus, two times the constructor is called, and two objects of the class ConstructorExample is created. ConstructorExample() written after the new keyword is responsible for the constructor invoking. Note that a constructor always returns the reference of the object created. obj1 and obj2 holds the reference returned by the constructor ConstructorExample().
Types of Constructor in Java
There are three types of constructor in Java
1) Default constructor
2) No argument constructor
3) Parameterized constructor
Default Constructor
Let’s see what happens if we remove the code of constructor in the above example.
FileName: ConstructorExample.java
public class ConstructorExample
{
public static void main(String argvs[])
{
// creating two objects obj of the class ConstructorExample
ConstructorExample obj1 = new ConstructorExample();
ConstructorExample obj2 = new ConstructorExample();
}
}
Explanation:
When we compile and run the above program, it does not show the output because there is no print statement in the program. However, the code is compiled and executed perfectly. Because the Java compiler implicitly inserts a default constructor in the code during the compilation of the program. It is not visible to user. Therefore, when ConstructorExample(), written after the new keyword, the default constructor is called. Hence, there is no error while executing the code.
For example, the default constructor inserted by the Java compiler is:
ConstructorExample()
{
}
Note: The Java compiler never inserts the default constructor when a constructor is defined in the code. Thedefault constructors always get the access specifier of the class for which they are defined. In the above code, the class ConstructorExample is public. Hence, the default constructor gets the access specifier public.
No argument Constructor
Consider the following program.
FileName: NoArgConstructor.java
public class NoArgConstructor
{
// no argument constructor
NoArgConstructor()
{
System.out.println("Inside the no argument constructor. ");
}
public static void main(String argvs[])
{
// creating an object of the class NoArgConstructor
// and invoking the no argument constructor
NoArgConstructor obj1 = new NoArgConstructor();
}
}
Output:
Inside the no argument constructor.
Explanation: Since, we have provided a no-argument constructor, the default constructor is absent. This no-argument constructor is getting called we create an object of the class NoArgConstructor.
Parameterized Constructor
A constructor with one or more parameters is called a parameterized constructor.
FileName: Employee.java
public class Employee
{
String empName; // contains employee name
int empId; // stores employee id
// a parameterized constructor with two parameters
Employee(String name, int id)
{
// initializing the fields
empName = name;
empId = id;
}
// A method printing the information of an employee
void printInfo()
{
System.out.println("Employee name is: " + empName + ", and his id is: " + empId);
}
public static void main(String argvs[])
{
// creating two objects of the class Employee
// invoking paramterized constructor to initialize the fields
Employee e1 = new Employee("Amit", 12345);
Employee e2 = new Employee("Sumit", 26789);
// printing the information of employee e1
e1.printInfo();
// printing the information of employee e2
e2.printInfo();
}
}
Output:
Employee name is: Amit, and his id is: 12345 Employee name is: Sumit, and his id is: 26789
Explanation: The parameterized constructor is used to initialize fields of the class. In the code, the constructor has two parameters: one for the employee name and another for the employee id. Therefore, while creating the object of the class, we have to pass the mentioned parameters in the same order; otherwise, the Java compiler punishes with the compilation error. Note that the above code does not contain any zero-parameter constructor. Therefore, a statement like new Employee(); must be avoided. Because the compiler tries to find Employee() in the code, which is absent. Since we have given a parameterized constructor, the existence of the default constructor is also ruled out.
Constructor Chaining Program
When a constructor of a class invokes another constructor of the same class, called constructor chaining. Let’s understand the constructor chaining through the following Java program.
FileName: Employee.java
public class Employee
{
// zero-parameter constructor
Employee()
{
// calling the paramterized consturctor that takes
// one parameter
this("Amritesh");
System.out.println("Inside the zero-parameter constructor.");
}
// parameterized constructor that takes one argument
Employee(String name)
{
// calling another constructor that takes
// two parameters
this(name, 78901);
System.out.println("Inside the one-parameter constructor.");
}
// parameterized constructor that takes two parameters
Employee(String name, int id)
{
// displaying the employee information
System.out.print("The name of the employee is ");
System.out.println(name + ", and his id is " + id);
System.out.println("Inside the two-parameters constructor.");
}
public static void main(String argvs[])
{
// creating an object of the class Employee and
// calling no argument constructor
Employee e1 = new Employee();
}
}
Output:
The name of the employee is Amritesh, and his id is 78901 Inside the two-parameters constructor. Inside the one-parameter constructor. Inside the zero-parameter constructor.
Explanation: When the statement new Employee() gets executed, the zero-parameter constructor is called. Inside the zero-parameter constructor, there is a statement this(“Amristesh”);, which does the construction chaining by calling the constructor having one string argument. Thus, the statements that are written after this(“Amritesh”); statement goes in the stack. Similarly, the single parameter constructor calls the constructor having two parameters. This time also, the statements after this(name, 78901); goes in the stack. The two parameters constructor executes the print statements written inside it. In the end, stack unwinding occurs, and whatever statements that are present in the stack get executed. The last two statements in the output are due to stack unwinding.
Constructor Overloading Program
Constructor overloading means having more than one constructor in a class that has different parameters. Here different parameters mean:
1) Number of parameters of the given constructors is different.
public class ABC
{
ABC()
{
…
…
}
ABC(int i)
{
…
…
}
}
Class ABC has two constructors: one has no parameter, while another has one parameter.
2) Number of parameters is the same, but the order/ type of parameters is different.
public class ABC
{
ABC(int i, String str)
{
…
…
}
ABC(String str, int i)
{
…
…
}
}
Class ABC has two constructors. Each constructor accepts two parameters. In the first constructor, the first parameter is of type int, and the second parameter is of type string, whereas in the second constructor, the first parameter is of type string, whereas the second parameter is of type int. These two constructors can be assigned different responsibilities as per the requirement.
Copy Constructor Program in Java
A copy constructor is used to copying the values of one object to another object of the same class. Like C++, there is no copy constructor in Java. We have to create the copy constructor explicitly. The following program illustrates the same.
FileName: CopyConst.java
public class CopyConst
{
// class fields
int ab;
String str;
// parameterless constructor
CopyConst()
{
ab = 9;
str = "ABC";
}
// It is a copy constructor that copies the values of one object
// to that object, which calls this copy constructor.
// This constructor takes the class object as the argument, whose values
// is going to be copied
CopyConst(CopyConst ob)
{
// copying the values of the object
ab = ob.ab;
str = ob.str;
}
// printing values of different fields of the objects of the class
void printInfo()
{
System.out.print(" Value of the integer field is " + ab + " ");
System.out.println("Value of the string field is " + str);
}
// driver method
public static void main(String argvs[])
{
// creating an object, and calling the parameterless constructor
CopyConst obj1 = new CopyConst();
// creating another object, and calling the copy constructor
CopyConst obj2 = new CopyConst(obj1);
// displaying fields of the given object
obj1.printInfo();
obj2.printInfo();
}
}
Output:
Value of the integer field is 9 Value of the string field is ABC Value of the integer field is 9 Value of the string field is ABC
Explanation: The one-parameter constructor is doing the job of the copy constructor in the code. The rest of the code is very straightforward to comprehend.